The bitter lesson is coming for software engineering
Coding agents are creating an uncomfortable tension in software engineering right now. We want them to work autonomously and quickly, but we also want them to produce the systems we would design ourselves. We prescribe interfaces, choose abstractions, and correct architectural decisions. We add custom linting and mechanistic checks to enforce our standards, choices, and codified “taste”.
I increasingly think this division of labour is temporary, and our idea of superior human judgement on systems design or coding standards is about to have a bitter lesson moment.
Feature engineering’s bitter lesson
In traditional machine learning (say, pre-2014), much of the work went into feature engineering. Humans chose which characteristics of a problem mattered and how to represent them, and models learned the optimal weights of those features.
We built language models based on linguistics research, speech models based on phonetics and acoustics, and image recognition systems based on visual features we thought mattered. Flower recognition was solved by explicitly extracting colour, shape, and texture. Speech recognition by building pipelines around phonemes, pronunciation dictionaries, and specialised processing components. Even the original AlphaGo, which defeated a human world champion, learned from human games and used hand-engineered features.
We essentially seeded the models with our human knowledge in order to make the problem tractable given the constrained compute and data available. But with more data and compute, deep learning moved much of that representation work into the learning process itself. It turned out, as Rich Sutton’s eloquently put it in the bitter lesson, that general learning methods without prior knowledge or specialization could outperform almost any human-designed system with enough data and training budget. Learned features by a generic CNN beat human-engineered features for flower recognition, simple RNNs beat speech recognition, the new AlphaGo was dubbed Zero because it started with zero Go knowledge, and of course auto-regressive LLMs exploded (no prior knowledge of linguistics, language, or anything really).
Architecture is feature engineering
Our current relationship with coding agents looks remarkably similar to the early 2010’s of machine learning. We define the codebase structure, the services, the core interfaces and abstractions. Within those boundaries, agents have freedom to find solutions. We let them learn the weights, so to speak, while keeping control of the overall system design, the features/problem design.
There are good reasons for this. Agents miss context, make poor decisions, and struggle to evaluate consequences that only become apparent later. An experienced engineer knows that a particular abstraction will make the next feature painful, or that a seemingly unnecessary boundary matters because of future product requirements. I, for one, have urged our engineers to focus on doing exactly this: constrain the agents as much as possible until we have super high confidence they’re producing high-quality code.
Engineer’s inputs are typically one of three things: simple correctness feedback, information inaccessible to the agent, or predictions about the future impact of a particular design.
First, engineers give direct feedback about code production like they would a junior engineer (i.e. “you didn’t do what I told you to”, “this isn't important”, “this is too complex”) This is usually either because the agent simply isn’t smart enough or because it misunderstood the problem. As intelligence improves, we should expect this type of input to disappear.
Second, engineers provide the agent with context it doesn’t have: product direction, other teams’ roadmaps, tech debt/migrations, operational constraints, or guidance on what to prioritize. This happens when agents optimize towards the wrong objective (e.g. over-optimizing, handling edge cases that can’t happen, writing unnecessary tests), ignore migrations, or build unnecessary things. This is purely a underspecification problem and is solved by providing better explicit guidance and context.
Last, engineers help predict the future impact of a design, i.e. if it’s a hack that will slow down future changes or a leaky abstraction that will make future changes likely to introduce vulnerabilities. This is typically what engineers call “judgement” or “taste” and is harder to internalize into the system, because agents don’t have access to the same signals we humans do - operational impact/reliability, slowness/poor experience of extending the code, impact on CI etc.
But if we could build a systems to solve all of these, and give agents access to the same accumulating information we humans have, why should humans be involved in designing the architecture at all? Architecture choices come from accumulated experience about what makes software reliable, efficient, and easy to change. There’s no obvious reason that experience must remain exclusively human. A system that can explore more alternatives, observe their consequences, and learn from them might eventually discover structures we wouldn’t have prescribed.
Just as in ML, the reason the lesson is bitter is that knowledge being displaced is the expertise we’ve spent our careers acquiring and the expertise we pride ourselves makes us “senior” and “great engineers”. We’re comfortable automating pure implementation, but considerably less comfortable with the thought that our architectural judgment would be not a force multiplier, but a constraint to better outcomes. Like the linguists of the early LLM era, we may find our own intuition to be inferior to machine intelligence.
Engineering as reward design
So what does that mean for us engineers? In machine learning, the work shifted from designing features to designing loss/reward systems. I believe we’ll see the same shift in engineering.
That means we should start treating implementation as a black box. Instead of focusing on creating systems and abstractions by hand, we should focus on building the right reward system so agents discover the right systems and abstractions by optimizing towards the goals we care about. Doing this for flower recognition was easy because the reward was a simple one-dimensional metric to optimize. For production code bases it’s harder because of the multi-dimensional, temporal, and hard-to-quantify nature of what we’re optimizing for. The correct reward is probably even different per-company and even per-team (e.g. feature teams optimize for velocity, infra teams for scalability and security). But in general it’s probably some quantification of a code base that allows us to ship code extremely fast, while being correct, secure, reliable, and scalable. It’s internal resemblance to something a staff engineer would have designed should carry no weight.
The bitter lesson is coming for us engineers. Our jobs are about to change once again. With intelligence improvements, engineering work is moving from building code ourselves, to guiding agents to good build code, to building guardrails that ensure agents build good code, to constructing feedback loops that let agents discover what good code is.



