What I’ll personally adopt

I’ll start with the conclusion -- what I will personally adopt when I teach, given my reading so far.

My main focus is to restore (or, augment) pre-AI out-of-the-classroom learning, a lot of which is recently being bypassed by unguided AI usage on homework. We do this by providing convenient, learning-inducing substitute AI, and by making the course grade be tied to proctored, in-person assessments.

AI-specific changes

Grading. The grading will be heavily placed on in-person quizzes and exams. Homework will have less weight, and each problem will just be graded on completion. E.g. 20%. The motivation to do homework is that the in-person quizzes will repeat some HW questions. If students bypass the thinking on homework, they’ll quickly learn they’re only harming their in-person quiz performance.

HW AI chat. For students who want to use AI, they are only allowed to use a problem-specific gemini gem, and are asked to turn in the chat transcript. I will have created a class-agnostic workflow that takes in the original problem statements and the reference solution so I can scale this process. This is to make use of the “sanctioned substitute” insight from psychology.

HW policy. AI usage is optional. If AI is used, students must (1) first provide a 30-minute first attempt that’s written on paper before (2) using the provided HW-specific chat, then (3) turning in the chat transcript.

Assessment content. I’ll be sure to add these flavors of tasks: (1) code review (2) plan review (3) provide test cases for this code and run them (4) conduct a runtime performance analysis of this code. This is to address the workflows that will become more common with AI-generated code.

Non-AI changes

These are other policies that I want to adopt from this post.

Active engagement. Lectures will include active worksheets, not just passive delivery.

Mastery. Students can retake quizzes up to two times, but for each to be a pass, they have to earn a very high grade (E.g. >90%). See mastery learning

Spaced repetition? I’m not sure if I can afford to add additional assessments, so I’ll only semi-encourage this through delayed assessments like midterms and final exams.

Other thoughts

AI detection. I don’t want to get into the cat-and-mouse game of detecting if students are misusing AI in the homework. If they do it and bypass the learning needed to succeed in the in-person exams, they will fail the class. That’s it.

Beyond this post. The interventions listed in the post surprisingly feel... very hands off. We hope that the student will use the convenient AI substitute, and realize that if they don’t do the hard thinking, they will fail the weekly quizzes. I’m curious what successful CS courses will look like a decade from now, and if we figure out interventions that are very different from the ones listed in this post.

Actual courses

Let’s first take a look at recent algorithms courses: UW, CMU, Berkeley, Stanford, Princeton. Here are the main findings.

In-person unchanged

The contents of in-person exams, lectures and curriculum don’t seem to have changed over the years. It’s worth noting that CMU and Berkeley have oral exams and oral homework, but I have doubts on how scalable this would be for single instructors.

Out-of-class support

What seems to change the most are the policies that shape how students interact with homework.

Grades: less emphasis on non-proctored. Proctored exams take the most weight. 4 out of 5 courses placed at least 70% weight on exams, with the exception of UW only placing 50%. Princeton and CMU don’t even grade homework, or only grade based on completion.

Homework: policy only. The homework content does not seem to be changed. The main change seems to be in the policy, which mentions that AI usage is optional, and if it is used, there is a guideline on how to use it. Here’s one from UW: “You are allowed to use the course approved GPT only after you have worked on the problem for at least 30 minutes.”

Custom AI. Only UW provided its own course-specific AI. Here is a chat transcript that I used to test it. The main benefits that I saw seem to be (1) non-disclosure of solution: “I don’t want to give away the full solution” and (2) next-step hints: “try comparing ... ask yourself ... A small conceptual hint: ...” (3) encouragement to think before re-engaging: “Spend 15–30 minutes trying to find the counterexample yourself before asking the next question.”

In summary, homework has less grade weighting, but comes with AI guidelines to ensure that the pre-AI thinking associated with homework is not bypassed. More details in the note: How real algorithm courses tackle AI.

CS Literature

We just saw a couple of concrete examples, and now we will broaden our search by looking at the CS education literature. We will mainly rely on Prather et al. (2025), which provided a list of course changes compiled from several papers and instructor interviews.

Grading change

There is an increased weight on proctored exams, and less weight on unproctored assessments like homework.

Update curriculum

More on code review, less on syntax production.

Educators believe code reading has become more important than writing code from scratch, and that higher level skills like code testing, problem decomposition, problem understanding, and debugging have become more essential (ES-4, ES-5). ... Developers pointed out a similar shift (DS-10), but added the need to critically evaluate GenAI use and its output, writing prompts, and meticulousness as new relevant competency components

Guide AI usage

Assume that AI will be used, and guide the usage.

Submission. Make clear what the policies are. E.g. Must share chat transcript if AI is used.

Guard-railed AI. Harvard (Liu et al., 2024) built course-specific AI that used socratic method and has access to the course materials. Here is a chat log where I played around with it. Note that UW’s custom GPT also is similar in spirit.

No AI for first step. Güner & Er (2025) suggested that students who code first, then later use AI just to refine, perform better than students who start their thinking with AI. A workflow that we want to encourage, then is as follows: (1) human does the first attempt without AI before (2) starting the loop of [AI provides minimal hints, human critically reviews before asking again].

Caveat: low epistemic quality

Note that the effectiveness of some of these interventions is not rigorously tested -- a lot of these were anecdotal, and not compared against strong baselines. See Bauer et al. (2025) for a more detailed look at the weakness of these studies. So! Treat this list more as a brainstorming tool.

Psych literature: AI cheating as an impulse-control problem

Let’s broaden our perspective even more and look at findings from psychology! If we reframe AI cheating as a behavior that students already intellectually know as bad, but find it hard to avoid in the moment, what are some effective interventions from the realm of psychology that we can adopt?

Strongest effect: convenient substitute with precommitment

The most effective intervention is to provide a sanctioned substitute to generic AI offerings, and provide an if-then plan (Sheeran et al., 2024; Gollwitzer & Sheeran, 2006). In the context of an algorithms course, we can provide a custom chatbot with pedagogically-sound prompts and give clear HW guidelines on how to use it. For instance, underneath every problem, we can give a clear instruction like this: “Start a stopwatch for 30 minutes to write your first answer on paper, then use this problem-specific course GPT (link) to check or get hints.”

Less established: Motivation

Appealing to honor codes, persuasion, or making students feel the delayed cost of cheating through frequent quizzes, doesn’t seem to have as strong evidence for reducing cheating on homework. This is pretty concerning, since this seems to be where most courses concentrate their interventions.

For more details, see the note Psychology: how to discourage ai cheating.

Class-specific AI

Given that providing an AI substitute is likely to be one of the more effective interventions, it’s worth diving deeper into how to build one.

Gold standards, and their approach

We previously saw how Harvard (paper, chat log) and UW CS courses have their own chat bots. However, the effectiveness of these chat bots hasn’t been studied to the level of rigor described in Bauer et al. (2025).

We will instead look at two more rigorous studies -- from a Harvard physics course (Kestin et al., 2025) and Google DeepMind (LearnLM Team, 2025). Both did Randomized Controlled Trials (RCTs) to show that interacting with the custom chatbot helped students obtain higher test scores with less study time, than students in a traditional active-learning class or with human tutors alone.

Here are the main components of building this solution.

1. Main ingredient: Human-curated step-wise explanations. It’s not the AI solving the problems. Instructors create the reference solutions decomposed into well-explained steps beforehand, and the AI refers to these solutions to figure out what hints to give.

2. Pedagogical principles guide AI. We have some of the principles baked into the prompts: don’t cognitively overload the student. Encourage active learning. Don’t give the answer, asking leading short questions. See the prompts for more details: LearnLM, Kestin’s .

3. Platform changes might be needed to provide an interface beyond a single chat box. For instance, Kestin et al. (2025) had separate chats for each problem substep, and clear UX to navigate between substeps and to see which has been completed vs not. The LearnLM Team (2025) study triggered the chat only when the student made a mistake on an MCQ.

Is it practical to build?

One might think that building a high-quality class-specific AI would impose too much additional work on single instructors. This is an open problem that I would like to tackle, but here are some preliminary thoughts that make me think it’s tractable.

Platform cost is free. UW used custom GPT, which doesn’t incur any cost to the instructor (details: CustomGPT QnA). If your institution offers Google accounts, you can use Gemini’s gems instead. Scaffolding is implicitly baked into the static homework statement, which links each section part to a different chat link.

Pedagogical principles are also easy to encode -- We can just reuse the same prompts from LearnLM Team (2025) and Kestin et al. (2025).

Human-curated step-wise explanations are probably a main bottleneck. We might reduce the cost by semi-automating it with AI. E.g. “Given this human-provided final solution, and the problem statement, break this down into steps”, then let human adjust the steps.

Evaluation as the hidden cost. Evaluation of quality is harder, but I suspect we might automate some steps that can produce a decent evaluation pipeline, and a self-improving pipeline that provides a good result. E.g. for this homework problem, generate 10 common student responses, evaluate yourself, self-improve your prompt, .... This will impose some monetary cost on the instructor, TBD on how much.

So, the main cost will most likely lie in the evaluation / self-improvement workflow and the step-wise explanation creation. It will be an interesting project to see how much of these can be automated, and various practical integration patterns to accommodate instructors of varying bandwidth. TBD for a future post!

References

• Bauer, E., Greiff, S., Graesser, A. C., Scheiter, K., & Sailer, M. (2025). Looking Beyond the Hype: Understanding the Effects of AI on Learning. Educational Psychology Review, 37(2). https://doi.org/10.1007/s10648-025-10020-8

• Gollwitzer, P. M., & Sheeran, P. (2006). Implementation intentions and goal achievement: A meta-analysis of effects and processes. Advances in Experimental Social Psychology, 38, 69–119. https://doi.org/10.1016/S0065-2601(06)38002-1

• Güner, H., & Er, E. (2025). AI in the classroom: Exploring students’ interaction with ChatGPT in programming learning. Education and Information Technologies, 30, 12681–12707. https://doi.org/10.1007/s10639-025-13337-7

• Jonany, S. (2026). Unregulated AI use harms learning. https://sjonany.github.io/posts/unregulated-ai-use-harms-learning.html

• Kestin, G., Miller, K., Klales, A., Milbourne, T., & Ponti, G. (2025). AI tutoring outperforms in-class active learning: an RCT introducing a novel research-based design in an authentic educational setting. Scientific Reports, 15, 17458. https://doi.org/10.1038/s41598-025-97652-6

• LearnLM Team, Google (2025). AI tutoring can safely and effectively support students: An exploratory RCT in UK classrooms. arXiv preprint arXiv:2512.23633. https://arxiv.org/abs/2512.23633

• Liu, R., Zenke, C., Liu, C., Holmes, A., Thornton, P., & Malan, D. J. (2024). Teaching CS50 with AI: Leveraging Generative Artificial Intelligence in Computer Science Education. In Proceedings of the 55th ACM Technical Symposium on Computer Science Education (SIGCSE 2024). ACM. https://doi.org/10.1145/3626252.3630938

• Prather, J., Leinonen, J., Kiesler, N., Gorson Benario, J., Lau, S., MacNeil, S., Norouzi, N., Opel, S., Pettit, V., Porter, L., Reeves, B. N., Savelka, J., Smith, D. H., Strickroth, S., & Zingaro, D. (2025). Beyond the Hype: A Comprehensive Review of Current Trends in Generative AI Research, Teaching Practices, and Tools. In 2024 Working Group Reports on Innovation and Technology in Computer Science Education (ITiCSE-WGR ‘24). ACM. https://doi.org/10.1145/3689187.3709614 (arXiv:2412.14732)

• Sheeran, P., Listrom, O., & Gollwitzer, P. M. (2024). The when and how of planning: Meta-analysis of the scope and components of implementation intentions in 642 tests. European Review of Social Psychology, 36(1), 162–194. https://doi.org/10.1080/10463283.2024.2334563

Deep dive notes

• Psychology literature: How to discourage AI cheating

• How real algorithm courses tackle AI

• LearnLM prompt

• Kestin’s prompt

• CustomGPT QnA

• UW’s custom GPT chat log

• Harvard’s CS 50 chat log

Here’s the abstract: Unregulated use of AI in courses breaks the out-of-classroom learning process, which is the majority of the learning time. It does so by providing a convenient, less guilt-inducing way to shortcut the hard thinking on homework. In bypassing important, strenuous active mental processes, students then fail to develop robust mental models.

Evidence that this is a real problem

Berkeley highest failure rate. As of June 2026, UC Berkeley computer science classes had a much higher failure rate than in the past. Some instructors attribute it to AI usage.

Garcia believes the “primary driver” of these abnormally high failing rates is due to a “vast increase in academic dishonesty” due to students’ usage of large language models, such as Claude, ChatGPT and Google Gemini.

Instructor surveys. In Prather et al. (2025), instructors reported a higher level of academic dishonesty and poorer performance on proctored exams. Here is an illustrative quote:

I don’t think we’ve ever had such large numbers of students who go into a test and simply can’t do anything.

Root causing: Cognitive offloading for homework

This is speculative, but I suspect that the main way in which AI harms learning is because students no longer learn well outside of the classroom -- because the cognitive effort for doing homework is offloaded to AI.

Why I focus on homework is because the course curriculum and in-person exams have not changed that much recently. One big change, instead, is how students learn outside of the classroom, and most of the learning happens through their homework. In support of this hypothesis, the previous section mentioned some instructors attributing the reduction in learning to academic dishonesty -- this most likely happens in unproctored settings, like when students are doing their homework.

Cognitive offloading. How does using AI on homework hinder learning? One possible reason is due to cognitive offloading (Risko & Gilbert, 2016), but there are more -- Bernstein et al., 2025 has a more comprehensive, AI-specific list if you want more ammo. Your brain needs to go through several active processes to capture new mental models. If you offload the cognitive work to another intelligence (an AI, or another human), the mental model never forms in your brain.

How this is worse than pre-AI

Even though pre-AI, cognitive offloading on homework was already a problem, this problem is exacerbated by AI for these reasons:

Accessibility. You no longer have to pay the social cost of asking your classmate for the answer. You can bypass the hard thinking with just a few seconds of typing. So, the cost of cheating is lower than it used to be.

Illusion of competence. You spend a minimal effort writing down your question, and instead of attributing the answer ownership to a non-human AI, you might intuitively feel that it is you who own the answer. After all, in the chatbox is just you and ... well, the AI. It is easy to feel that the personalized AI chat is an extension of you, more so than you feel like a publicly available solution manual or a classmate is an extension of your thinking. Finally, this mistaken ownership misleads you into thinking that it was your competence that produced the work. Bernstein et al. (2025) mentioned the term “illusion of competence” to capture this effect. The result, then, is that you feel like you crushed the homework, only to be surprised by how you are unable to repeat the same performance during in-person exams.

Next steps

If turning a blind eye to AI usage is setting up students for failure, then what can educators do? Can we do better than just writing an AI policy doc? Can we do more so that we can use AI to accelerate learning instead - and what’s actually practical for a single instructor? We’ll tackle this on a future post...

References

• Risko, E. F., & Gilbert, S. J. (2016). Cognitive offloading. Trends in Cognitive Sciences, 20(9), 676–688. https://doi.org/10.1016/j.tics.2016.07.002

• Prather, J., Leinonen, J., Kiesler, N., Gorson Benario, J., Lau, S., MacNeil, S., Norouzi, N., Opel, S., Pettit, V., Porter, L., Reeves, B. N., Savelka, J., Smith, D. H., Strickroth, S., & Zingaro, D. (2025). Beyond the Hype: A Comprehensive Review of Current Trends in Generative AI Research, Teaching Practices, and Tools. In 2024 Working Group Reports on Innovation and Technology in Computer Science Education (ITiCSE-WGR ‘24). ACM. https://doi.org/10.1145/3689187.3709614 (arXiv:2412.14732)

• Bernstein, S., Rahman, A., Sharifi, N., Terbish, A., & MacNeil, S. (2025). Beyond the Benefits: A Systematic Review of the Harms and Consequences of Generative AI in Computing Education. In Proceedings of the 25th Koli Calling International Conference on Computing Education Research (Koli Calling ‘25). ACM. https://doi.org/10.1145/3769994.3770036 (arXiv:2510.04443)

• The Daily Californian (June 2026). Failing grades soar as professors see greater AI usage, dwindling math skills in UC Berkeley. https://www.dailycal.org/news/campus/academics/failing-grades-soar-as-professors-see-greater-ai-usage-dwindling-math-skills-in-uc-berkeley/article_16fad0bf-02cb-4b8c-8d88-888ffd9f8608.html

• Jonany, S. (2026). How to build mental models for CS concepts. https://sjonany.github.io/posts/how-to-build-mental-models-for-cs-concepts.html

Mental model definition

We first refine our understanding of “mental models” with this quote from Robins et al. (2019) “Expert programmers are characterized by a large library of useful schemata/plans that chunk and organize significant amounts of information in a form that reduces cognitive load. Many of the difficulties experienced by novice programmers arise from their lack of such organizing knowledge structures.”

So! Mental models are like brain-shelves that allow you to think more efficiently. You would be able to load more concepts into working memory and manipulate them with less mental tax. The more you have, the more efficient your thinking is. Let’s take a look at the mental processes needed to develop them.

Processes that develop mental models

As for how to develop these brain-shelves, you need to actively go through thinking tasks of varying levels of guidance in varying contexts.

Mode: active

In all the phases that we will see in the later sections, the most important qualifier is that you must actively engage with the material. By active, we mean one where you reconstruct from memory, without referring to external material. This is one of the two techniques rated as “high utility” in Dunlosky et al. (2013)‘s review of learning strategies. Some examples -- Active: self-testing verbally while closing your eyes. Non-active: highlighting textbooks.

The “no external material” part makes sense (that means no looking at textbooks or AI output, mind you). The mental model exists in your head. To build this mental model, you need to exercise / shape / mold it enough such that you can reproduce the study material without external help. That’s how you ensure that the mental model, on its own, is robust enough.

In practice. When I was a student, I tried to reconstruct the lecture materials from scratch on an empty piece of paper, and only looked at the lecture slide when stuck. This is like “self-quizzing”, but more thorough in that I really do try to re-derive all the concepts, as opposed to just filling in small blanks. There’s the pro that I don’t have to create flashcards too! The flash card is the lecture slide itself.

More readings on active recall here if interested: 1 2

Phases

Okay, we emphasized that we must be active in how we approach our learning. Now we’ll go through roughly-ordered phases that help you develop your mental model:

1. Build your initial model by going through and reconstructing the guided instruction / lecture slides

2. Test. Stress-test your mental model by doing practice problems from homework and quizzes

3. Retain. Review the material at a later date to make it stick.

Build: Go through guided instruction. You start by reading through known materials and self-explain these in multiple passes until you can go through all below from scratch. Here is a list of concepts that ideally exist in the guided instruction (i.e. your lecture notes). If you want the more authoritative source rather than my personal re-ordering, please see the references section below.

• Example. Go through a worked example. E.g. video. For a given concrete problem, work through example inputs and outputs, and a simulation run of the algorithm.

• Direct schema explanation. E.g. video. Explain the abstract concepts that are generalizable across the examples, like optimal substructure, then relate this to the examples.

• Decomposition. If the process has multiple logical subcomponents, label the subcomponents explicitly. E.g. handout. Especially for anything that’s sequential like “First, define your solution, second define your measure, third prove that greedy stays ahead”, give a functional label to each step and provide per-step examples.

• Map to known mental models. Map to familiar concepts so you can link to existing mental models. Analogies can work well here. E.g. To minimize total debt payment, you prioritize paying off the highest-interest debt first. You intuit that focusing on just the one highest-interest debt at a time will be best for you long term.

• Negative examples. Show common misconceptions. E.g. show intuitive approaches that are wrong and counterexamples.

• Multiple examples. Go through multiple examples to ensure that your mental model is of the right level of abstraction to at least generalize to them. E.g. handout

• Intuitive explanation. You should create explanations that are intuitive to you by (1) Drawing a diagram and/or (2) Having a one-liner explanation that may sacrifice accuracy for intuitiveness. This personalized representation is the main form that you would invoke in real life, outside of class, and should be personalized to you. I usually do this at the end of every lecture by writing a TL;DR section at the top of the document with one-liner explanations of the important concepts. E.g. When I think of greedy algorithms I think of “pick locally optimal moves that are also proven to be globally optimal”. Or when I think of “breadth-first search” I can visualize a cloud that expands concentrically from a middle point.

Test: Practice / apply. This is where homework comes in. You see if the mental model developed by going through the known materials is flexible enough to generalize to new materials.

• Solve novel problems. Go through past exams or programming contests.

• Interleave problem types. Go through a set containing problems of different types without knowing which technique to use to see if you know when to apply a certain technique vs another.

Retain: Spaced repetition. This is the only other top-rated tip from Dunlosky et al. (2013). If you want something to stick, review it periodically. The scattered cadence of quizzes, homework, and exams kind of already does this for you. To quote: “To remember something for one week, learning episodes should be 12 to 24 hours apart; to remember something for five years, they should be spaced six to 12 months apart. Although it may not seem like it, you actually do retain information even during these long intervals, and you quickly relearn what you have forgotten.”

Putting things into practice

Student. As a student, after every lecture, do the following:

• First pass. Go through the lecture slides to see if you can understand each slide even on a passive read. If you don’t understand something, ask someone / AI.

• Augment. Augment each slide with list items from the previous section that are missing. E.g. Use AI to come up with another example of the same concept, if you don’t get it yet. Or you can also ask AI to decompose a complex algorithm into subcomponents and give each an intuitive one-word label.

• Second pass: reconstruct. Go to a room with 0 internet, an empty piece of paper, and a printout of the lecture slides. Regenerate the lecture slide by just looking at the slide title, but don’t look at the slide detail unless you are stuck.

• Third pass: intuition. Put a TL;DR section at the top of your note. Give one-liner explanations and visuals of the important concepts.

• Practice. Do a lot of problems. Usually homework and past exams are enough. You should do the thinking on your own first, and only check the solution, or use AI after you’re stuck for, say, more than 15 minutes.

Instructor. As an instructor, the job is to create a learning environment that encourages students to go through all the mental processes as mentioned previously, both inside and outside of the classroom. This will be tackled in a future blog post.

What’s next?

In summary, to develop mental models, you need to be able to actively reconstruct the material from memory and test it against a variety of problems. To retain them, you would revisit the material at least a week after you learnt it.

That’s a lot of work though! In subsequent posts, let’s see how external agents like CS educators and AI can help or hinder students as they go through these requisite mental processes.

References

Dunlosky, J., Rawson, K. A., Marsh, E. J., Nathan, M. J., & Willingham, D. T. (2013). What works, what doesn’t. Scientific American Mind, 24(4), 46–53.

• Their full peer-reviewed review: Dunlosky, J., Rawson, K. A., Marsh, E. J., Nathan, M. J., & Willingham, D. T. (2013). Improving students’ learning with effective learning techniques. Psychological Science in the Public Interest, 14(1), 4–58.

Robins, A. V., Margulieux, L. E., & Morrison, B. B. (2019). Cognitive sciences for computing education. In S. A. Fincher & A. V. Robins (Eds.), The Cambridge Handbook of Computing Education Research (pp. 231–275). Cambridge University Press. https://doi.org/10.1017/9781108654555.010

• Chapter 9.6 is my main reference for the “guided instruction” section.

https://teachtogether.tech/en/

• The six strategies section here has a lot of overlap, and a lot more references

What’s a mental model?

Wikipedia’s definition is “internal representation of external reality”. I’ll expand a bit.

• When we have a model of a system, we can predict the system’s behavior under various inputs, and even system modifications. We can also reconstruct / manifest the system in real life (e.g. by coding it).

• When we say the model is mental, we mean the model exists in your mind. It’s in a format that’s amenable to thinking.

Why build a mental model?

That is, why can’t we just rely on the mental models that exist in an AI? Here are 3 reasons -- one for each kind of interaction: [with other humans, with AI, and with yourself].

1. To communicate with other humans

Here are some practical scenarios. During a design review, a senior engineer says: “Let’s cache this. But remember to add invalidation code in the real-time write paths.” Or, your co-founder, during a brainstorming session says: “I’m not sure if the round-robin approach to fairness is enough. We also want to incorporate how many times the job has failed for each customer, and their subscription tier.”

It’s not acceptable for you to always respond with “Oh sorry give me 1 hour to learn about these topics with AI first.” Conversations that happen in real time require you to have a lot of mental models pre-built in. If you don’t have a rich library of mental models, fewer people would want to collaborate with you.

2. To steer AI

You also need mental models even for workflows where no human is waiting for your response in real time. Consider your workflow as you review an AI’s design or code output. You might argue that you don’t need to have a mental model for understanding the AI’s output beforehand, because you can simply have conversations with the AI to build the mental model on the fly. But (1) will you want to do this when you are mentally tired and you have an impending deadline? (2) do you even know about the right clarifying questions to ask, if you don’t know about the pertinent design choices for the system?

As an example, when you review code, you might quickly have spidey-senses that go like this: “Huh, there’s a for loop in this DB transaction, and ... wait there are remote calls in this loop?! Whoa, this transaction is going to hold on to the locks for a long time.” As you scan through a lot of code files, you need to have this kind of reasoning happening in real time to be able to flag which sections to probe deeper with AI. Without a rich mental model of DB transactions, locks, and network calls, you would not be able to truly verify and be a responsible steward for the code generated by the AI (i.e., you produce AI slop).

3. To communicate with yourself / generate authentic thoughts

In all the examples above, you need to chain thoughts together to respond to the world. Chaining thoughts requires mental models that are readily meldable to each other, as well as to your goals.

I suspect that chaining in real time, without waiting for AI, is important for generating thoughts that are closer aligned to your values. I’m not saying that we shouldn’t use AI. I’m saying that in the process of iteratively refining what you want, when it’s your turn to think and provide an input to the AI, sometimes you might want to think harder, or heck, even take a walk first, before writing the prompt. This is because this self-driven thinking is intimately tied to your personal sense of “good”. E.g. I recently went on a thinking walk to figure out what kind of app would help me keep track of my jazz repertoire. At the end of the walk, I decided that I just want a simple app that has 0 cloud components, and one that has a video-game-like interface. It’s unclear if I would have come up with a simple, personally delightful solution if I hadn’t done this thinking alone first.

Another angle to see this is to think about system inputs and outputs. If you don’t think too much before writing prompts to feed into AI, then you will probably just feed in the top K prompts that other humans have fed in, and in turn get the same small space of responses. You are unlikely to generate thoughts that are uniquely you.

Conclusion

Building mental models within you allows you to think for yourself, collaborate with others, and steer AI more effectively.

As for how to build them (and how AI can help or detract) ... that’s for a future post!

Record Computer Science (CS) colliding with a cooling hiring for entry-level software engineers (SWE).

The environment is harsher, so you have to be more intentional and work harder than your seniors did. Realistically, expect 100+ applications, lots of rejection, and a search that takes months. This is the norm, not a sign you’re doing it wrong. With that in mind, here is an updated list of advice I would give to myself if I were a CS junior today.

EDIT (5/31/2026): 80000hours.org has this awesome in-depth guide. I especially love this section on motivation:

Your first job search may be one of the hardest things you’ve ever done. You may have never been rejected 30 times in a row before. It can involve months of work. And you may have to do most of it alone. It can make online dating look easy. This means you’ll need to throw every motivational technique out there at it. The most useful is to pair up with someone else who’s job hunting.

Commit to daily habits

If you take away one thing from this post, take 5 minutes to do the following. (1) Schedule two recurring 30-minute blocks on your calendar every day — one for applying, one for upskilling. (2) Create 2 Google Docs to track action items for each session. For now, each doc should have only these two items: (1) fill in the list with items from this post (2) reorder by priority based on where you’re at and which jobs you’re targeting.

Prereqs

These are minimum requirements that you want to clear ASAP before you start applying.

• Class: Data structure, runtimes. Take a junior-level data structures (UW CSE 332 Edmonds CS 143) class ASAP. I heard this recommendation a decade ago as a junior, and after a decade in industry, I still stand by it. If you don’t have a clear understanding of priority queues, hashing, and big-O runtimes, you will most likely fail technical interviews — and even if you pass, your teammates will be frustrated that they can’t have meaningful conversations with you about runtime performance and data manipulation.

• Project: At least 1. Have at least 1 project, either personal or from a capstone class. Make sure it has a GitHub page that explains why the project is useful (a video works well — see example) and a link showing your design thinking (example).

• Resume. Have a LinkedIn profile and a document-form resume. If you have time, also build a personal website.

Get interviews

• Start ASAP. Start applying for internships and full-time opportunities as soon as you’ve finished your data structures class. Use multiple job search sites, look at your college’s career programs, and figure out when the interview cycles start (example).

• Personalize your resume. Before you apply, tailor each resume to the job, if possible. AI makes this easy. E.g. for an embedded engineering role: (1) reorder your projects so the embedded capstone is at the top, and (2) update the profile summary so the hiring manager sees you as a great fit. A friend of mine wrote an AI-based script to automate this :D — something like: “Given this job description and my resume, can you output a personalized resume? Here are some personalization examples: …”.

• Reach out actively. Send personalized cold emails to real people in addition to the hiring portal. If a company you’re really interested in doesn’t have a hiring portal, reach out anyway. See example.

• Leverage connections. Is there anyone in your network willing to vouch for you? E.g. when I was a wee baby in community college, fresh out of my second CS course, I asked my professor if there was any collaboration opportunity I could take. He was kind enough to hook me up with a research project at another university.

• Increase breadth. A tiered approach works well: for companies you really want, do the costlier tips like resume personalization; for the rest, just mass apply. If you’re not getting any bites for SWE positions, apply to adjacent roles like QA, support eng, devrel, TPM, IT, contracting, or smaller no-name startups. One success story: a friend of mine got a support eng role at a startup and was also offered SWE projects with the potential to switch to a SWE role.

Build skills in parallel

• Budget your time: Level up v.s. apply. Figure out the right balance between time spent finding new opportunities and time spent upskilling. I personally would cap applications at 30 minutes per day, at the end of the day when my brain is tired. The rest is reserved for upskilling, unless I feel my skill set is already strong enough relative to peers who got jobs.

• Show excellence, and network. Be excellent to the people in your program — professors and classmates. Do well in your classes. Show up to office hours with thoughtful questions. Find excellent classmates and do projects with them. Are you the kind of person your professors and classmates would be delighted to help succeed (e.g. referrals, mock interviews, sharing interview experience)?

• Research the interview meta. For the companies you’re interested in, are they still asking leetcode questions? Do they allow AI? Ask your classmates who recently interviewed. Some sites like LeetCode (premium-only, but some lists are public) also show recent questions asked per company.

• Research the work meta. What skills are now needed on the job at the junior level? Ask your seniors who recently got a job. E.g. Guha et al., 2025 notes that “being able to rapidly read and understand code is more important than ever.” Take courses and build side projects that exercise these skills.

• Learn. Learn those skills either by taking courses (e.g. an algorithms course if leetcode-like questions will be asked; software engineering group project capstones never hurt) or by self-study.

• Personal projects. Build more personal projects that tick the keywords your ideal jobs are likely to look for. Interested in mobile development? Look at the job postings and see which popular framework to use.

• Personal list: AI, cloud infra, system design. This one is more personal. When I was in charge of hiring at a startup, my main qualm with junior engineers was that I couldn’t validate how effective they’d be as a colleague — they lacked the vocabulary to even talk about the practical building blocks of system design. I’d ask questions like “Where would you host this code?” and get uncertain answers like “Oh, idk, a jupyter notebook?”. Most university courses unfortunately don’t touch on the practical technologies real engineers use day-to-day, so you would have to learn these on your own time. To fill the gap, find walkthroughs you can follow along with (example) and build personal projects that exercise these concepts. As of May 2026, I would recommend that you at least know what these are for and be able to converse about them: [docker, terraform, LLM API, S3, EC2, dynamodb].

Pass the interview

• Understand the format. Ask the recruiter what the interviews are like, and whether AI is allowed. E.g. from a friend I coached: “Per your advice, the day before I asked if I was allowed to use AI/the internet during the interview, and they said no. In the interview, the interviewer said 90% of candidates have been using AI and they would stop the call if I was caught, so I felt good knowing that ahead of time.”

• Beyond coding interviews. Check if there are interviews beyond just coding rounds — usually system or behavioral rounds. Prepare for these too, including behavioral. Use AI to brainstorm a list of questions, answer each one, then add trigger keywords for each answer so you can recall your answer outline on demand.

• Practice with humans. Ask your friends or mentors for a mock interview.

• Practice with AI. Use LLMs to craft interview questions and practice against them. An example prompt: “Given this job posting […] and the emails from the recruiter […], what questions are they likely to ask?” I had great luck with this approach – I helped a friend pass a data analyst interview by giving a mock interview using this method. She said: “I wanted to let you know that the coding interview on Tuesday went well! The coding part was close to the practice you set up with tables, and I was asked to explain how I would achieve certain objectives in the Google Doc with SQL and Python. I felt super prepared based on the examples we worked through! “ Then a week later, a celebratory email: “I wanted to let you both know that I got this job!! I accepted the offer on Tuesday :)”

Hoo boy. That’s a lot of information. Now go back to the earlier section on “Commit to daily habits” and start executing!

Grades should reflect unaided ability

Grades should at least partially reflect the students’ ability to compute using the concepts taught in class without the use of AI.

But we have access to AI irl, so why improve unaided ability? One’s unaided ability still matters, even in the age of AI. This is because some flows — like self-driven brainstorming (where you play around with concepts you have a good grasp of) and conversations with other humans — require that some concepts be readily computable without going back and forth with AI.

Aids are more accessible now. Q: Ok sure, unaided ability is important, but that’s already true pre-AI, so why bring this up now? A: Because with AI, the cost of cheating is much lower than in the pre-AI era where you need to have another human to cheat with. You don’t need to incur a social cost — it’s as simple as doing a few keystrokes.

How to grade unaided ability: In-person examination

The current best way to prevent students from using AI for the evaluation process is to do it in-person.

Weak attempts. It’s worth noting that online courses like Harvard CS50 used proctorio, which of course can be bypassed.

What it takes: Sense check. To ensure that students only use their brain to take the exam, and not another brain (another human, or AI), one must ensure that all sense inputs that the student receives don’t contain new information — e.g. no new visual or audio cues that contain information that help the students. Today, the cheapest and most reliable sensor to achieve this is to have the instructor double up as a human proctor.

To conclude! Courses that need to output grades, and want to evaluate the students’ unaided ability, will likely need in-person exams for a long time.

Futuristic brainstorming

As a fun brainstorming exercise, if I have a reasonable budget from the teaching institution, and I am forced to host an exam remotely, I will want to use a combination of the following:

• Student-perspective visual and audio recording. E.g. These glasses cost < $50. This will help detect if the students are cheating using another device.

• Wide-perspective visual and audio recording. Have a wide-view recording using a phone that shows the student’s side profile and the workspace, to show that there is nobody else in the room, and that the student is wearing said glasses.

• Both of these recordings are linked to the exam-taking platform, such that if the platform detects that one of the recordings is malfunctioning, we will pause the exam and tell the student to fix it.

But practically speaking, if I’m suddenly forced to teach an online class, I would just use an existing platform like proctorio.

A: Yes, because coding is an effective learning mechanism to learn about computing concepts, and we need this literacy to navigate some nuanced trade-offs of complex real-world systems.

— Now let us dive deeper.

Previously, I argued that even when AI can do everything for you, humans still have to learn and be able to compute some complex concepts in real time, in order to collaboratively want better. But what are these complex concepts? For this post, let’s focus on a specific aspect of computer science education.

You need to read and write code to learn computing concepts — because coding is active learning

Let’s take a look at what you learn as a CS freshman. Using a language like Python, you would learn how to read, think through, make mistakes, and debug concepts like conditionals, loops, and function compositions. I remember my very first encounter with loops and functions — I had to play around in my IDE and make mistakes before I finally “got it.” This act of playing around requires something that is easy to read, edit, and run — and a programming language like Python is a good example. You could also say that coding is a very active form of learning, and this interactivity helps you understand concepts better. These basic concepts are then prerequisites for learning about data structures and algorithms, which IMO are really powerful mental toolkits for anyone to have. And this brings me to my next point…

Computing concepts are needed to “want” better

You need the concepts taught in data structures and algorithms classes to make design choices in some real-world systems. Let’s take a look at a few examples: resource prioritization and matching. When designing complex systems that have to satisfy conflicting interests of multiple human users, you might have to make decisions like “I prefer round robin instead of a priority queue based on a weighted average of the user’s features x,y,z because simplicity implies understandability and trust”, or “I want my dating platform to use the Gale-Shapley algorithm and I know about its pros and cons.” The book Algorithms To Live By has more examples.

Conclusion

I feel more optimistic about claiming that for the foreseeable future, it is useful for some people to take CS 101, where you would learn how to read, modify, and make mistakes with a programming language that teaches you loops, conditionals, and function composition. They set up the basis for you to learn complex computing concepts that are necessary to navigate real-world tradeoffs.

Appendix: Weaker arguments

These are arguments that I initially considered, but later discarded.

Because AI might be malicious / have poor implementations. The argument here is that even if the AI understands your intention, it could implement something else that could be dangerous, and so it’s up to the humans who have code literacy to save the day. See Anthropic’s blog post for a clear example. However, as argued by the book If Anyone Builds It, Everyone Dies, if the AI is more intelligent than a human, then they will be able to craft hidden implementations that humans would be hard-pressed to detect by just reading the code.

• In the more immediate future, where AI still makes human-correctable mistakes, this argument holds. Clawdbot is a good example — It is useful for most to understand common security concepts, and guide the AI to provide a safer implementation.

Because there are some use cases where you have to go down to the level of precision of code to achieve what you want. This I am less sure of. For most design decisions, I probably don’t need to go down to the level of for loops to dictate my preferences. I suspect for most design decisions I make, I could have just used a lot of vocab from my data structure and algorithms class without even mentioning the word “for loop”.

Hopefully not :) Here’s a counter claim: Education is necessary for one to want better. This is because to want better, you need to

1. Know enough concepts to shape what you want and

2. Meld what you want with other humans’ wants

Both of these require that you, not the AI, have the right reasoning and conceptual building blocks readily computable in your brain. Let’s go through each one of these points.

Shape your personal want

Real-life problems don’t have one optimal solution. They are filled with nuanced tradeoffs, and being able to understand these tradeoffs requires you to understand mechanisms across a wide variety of systems. As an example, if you are building an AI-backed product, you might want to reason: “How should we charge users for the inference cost? Should we show the user ads, which charge for their attention, instead of money, since more people have attention than money?”

A first-grader would have a hard time even saying this sentence out loud. For them to seriously deliberate on this tradeoff, they need to at least grasp concepts like attention, money, ads, inference, etc.), have the reasoning skills to map these options against their personal moral values that they hopefully have crafted to be mostly good for humanity.

Meld your want with others’

Communicating with other humans with different wants is how you increase the chances that your want is a solution that benefits others — and usually the development of your values requires you to think about humanity at large, not just yourself anyway.

More pressingly, to communicate with other humans, you need to be able to do the above in REAL TIME! It’s not okay to me that while I’m discussing with my cofounder, they would say: “wait sorry I don’t understand the tradeoff between latency etc, give me an hour to catch up”. Negotiation, empathy, and collaboration happen at the speed of human conversation. This then requires that you, not AI, also have the mental agility to reason about these concepts in real time. Developing this mental agility requires hard work.

Conclusion

Before handing your 10-year-old the lamp (with a clawdbot sticker on it), make sure they know what to wish for and how to explain that wish to the rest of the world.

CS education? How deep down the mechanistic level does one need to shape one’s want? What kind of wants would require one to go through CS undergrad education and learn how to read Python code? See this post.

Another thought: Learning to shape your values. To blindly accept AI-generated work before thinking carefully about your want is to blindly accept an alien value.

Here are some reflections that led me to this decision.

Why transition now?

• The startup I was working at just hit a milestone (with WHO!), and I thought it’s a satisfactory end to my time there. 1 2.

• I have been in the software industry for over a decade, and feel a larger change is overdue.

• I got interested thinking about AI and education 1 2 3

Why teaching?

I love teaching. I TA’ed 4 times during my time at UW. When I was working, I gave friends of friends mock interviews and piano lessons. I love the process of figuring out how to help the person in front of me understand a concept. I find the memories – where I helped somebody get a job, or watched someone glow with excitement when they understood a new way to play their favorite songs – to be deeply meaningful.

On the other hand, I also love hard solo thinking on open frontier problems. I like learning and doing research on state-of-the-art problems. The intersection between CS education and AI is rife with many of these open problems! The end goal of serving the students effectively in this volatile space naturally requires one to stay abreast of recent research findings, and to be thoughtful about how to apply them. What a privilege to be able to do both!

How is this different from my previous path?

Here are a couple of novel job attributes that this teaching path will tick:

Peopleful. I want my day-to-day to be filled with human interactions that feel … for lack of a better word, more human. When I was a software engineer, while there was space for a lot of positive human interactions, my main mode of communication prioritizes efficiency – I want to give and get information with the fewest messages exchanged as possible. I suspect that having a job where the objective is to directly help the human in front of me not only to understand, but to want to understand, will give more room to the more empathetic side of me.

Soul-building, value-alignment. On a more woo-woo note, I value thinking, loving, and playing, and would like to leave the world with more people who do these. Teaching seems to tackle all of these at once. I get to think hard about the materials and how to make them digestible and entertaining to the students. I will also likely get to face more interpersonal challenges as I try to care for humans who are balancing the struggles of not only the curriculum, but also life. There’s a lot of personal growth to be had in this new journey, and I look forward to it.

Are you done with software engineering then?

Nope. I still love building software, and will likely do it for a long, long time. I will just be more selective with the problem I’m working on, and right now it’s CS education in the age of AI.

Ending words

This is all written before I start the teaching position, so I’m also looking forward to seeing how I feel after my first quarter of teaching. That’s for end-of-the-year Stephen to reflect on!