We should be more tired than the model | ✰Vicki Boykis✰ ✰Vicki Boykis✰Tech Blog
Essays
RSS
GitHub
About
Changes
AIWe should be more tired than the modelMay 28 2026Lately, I’ve been feeling like I’m losing control over the code I write when I work with agentic code generation.When I finish an agentic session, I get all the outward signs of having written code, but none of the internal processes that happen when we write code by hand.As a quick primer, the human brain has several types of memory, short-term, working, and long-term. Short-term memory gathers information temporarily and processes it quickly, like RAM. Long-term memory includes things you’ve learned previously and tucked away, like database storage. Working memory takes the information from short-term memory and long-term memory and combines them to synthesize, or process the information and come up with a solution.When we’re working on code, (and by working on, we mean most often reading someone else’s code) all of these processes are going on in our brain simultaneously to try to help us make sense of the programming environment.It’s not surprising. Code generation, in its default mode, is antithetical to skill retention, particularly because its UX affordances are reminiscent of a slot machine’s: you pull the lever, you get a reward (a solution to your coding problem.) In some ways, we’ve replaced the social media feed with a stream of tokens, and I look forward to reading those papers in ten years.It really does take extra concerted effort to move from just generating answers to using the tool deliberately. One thing Oz suggested when I posted on X that I felt like I came away from an agentic session with a brain fog was rewriting portions of code myself.Inspired by that advice, the paper, thoughts on slowing down, and using AI to write better code more slowly, and Mitchell’s adoption journey, I’ve been working on using the tool more deliberately and adding friction back into development.Here’s what’s worked for me so far:Writing the initial implementation myself and asking the agent to review the code, then going through comment by comment and manually making the changesUsing the agent to keep asking questions about pieces of the code I don’t understand instead and pull up relevant documentation and PRs.Asking the agent to think about implementing two approaches and choosing between them and then critiquing the other approachDiscussing an agent’s proposed implementation with another person insteadStarting to use the agent only after I’ve spent 20 minutes on the problemGoing back and reading books and academic papersReimplementing fundamental data structuresAll of these negate the supposed speed up effects of LLM-generated code in the short-term by adding friction, and yet, in the longer term, make me better at using the tool, because they solidify my own foundation instead of the foundation models'.We should be more tired than the model.#learning
#llms← Tagging my blog posts with BERTopic and LLMs#engineering
#data science
#career advice
#code
#machine learning
#data
#software craft
#python
#learning
#engineering culture
#talks
#web dev
#deep learning
#distributed systems
#community
#search
#writing
#computing history
#normcore
#open source
#product culture
#recsys
#social
#embeddings
#art
#shipping
#type systems
#creativity
#golang
#llms
#snippets
#algorithms
#aws
#prodMade with Hugo ʕ•ᴥ•ʔ Bear

The author reflects on the cognitive challenges encountered when engaging with agentic code generation, noting a disparity between the visible output of code and the underlying internal processes involved in manual coding. The reflection begins by establishing a framework for understanding human memory, distinguishing between short-term memory, working memory, and long-term memory, where working memory synthesizes information from both to derive solutions. The author posits that engaging with programming, especially when involving reading existing code, necessitates the simultaneous operation of these memory systems to comprehend the programming environment.

The experience of code generation is framed as antithetical to skill retention because its design often provides superficial rewards, similar to a slot machine mechanism where a lever pull yields a solution. This flow encourages a focus on obtaining immediate results rather than deep skill internalization. The author argues that moving from simply generating answers to deliberately using the tool requires introducing necessary friction back into the development workflow to counteract this inherent tendency toward passive consumption.

To achieve this deliberate usage, the author details several strategies that have proven effective. These methods involve actively engaging with the code generation process by requiring greater cognitive effort. Successful techniques include writing the initial implementation independently and then utilizing the agent solely for review, followed by manual, line-by-line modifications. Another strategy involves prompting the agent to engage in deeper problem-solving, such as asking it to investigate areas of confusion by pulling relevant documentation or pull requests, or asking it to evaluate and critique multiple alternative implementation approaches.

Furthermore, the author suggests pedagogical methods for development, such as reserving the use of the agent until twenty minutes have been dedicated to problem-solving, revisiting foundational knowledge through reading academic papers, and actively reimplementing core data structures. These actions are intended to diminish the perceived speed advantage of LLM-generated code in the short term, but they serve the long-term goal of solidifying the user's intrinsic foundation of knowledge rather than relying on the foundation models themselves. Ultimately, the core thesis is presented as a call to operate with greater intentionality to ensure that the interaction with AI enhances, rather than bypasses, the necessary cognitive effort required for true mastery.