An Architect's Taste May Just Be a Bias That Hasn't Been Measured Yet
Jacob Lauritzen argues that coding agents will replay the bitter lesson from machine learning: the architectural judgment engineers pride themselves on may go from an advantage to a constraint. The replies are fiercely divided—some bet it has already happened, while others insist that refund calculations still have to be handwritten.
Software engineering is developing an uncomfortable tension. Coding agents are getting more capable, but engineers still want them to produce systems 'we would have designed ourselves.' So they specify interfaces, choose abstractions, revise architecture decisions, then add custom lint and mechanical checks, writing standards and taste into rules. Jacob Lauritzen is the CTO of Legora. In a post/article on X, he argues that this division of labor is temporary and that software engineering will have its own bitter lesson.
bitter lesson comes from Rich Sutton. In traditional machine learning, a lot of work went into feature engineering: humans chose features and defined representations, and the model only learned weights. Later, as data and compute increased, deep learning took over representation learning too. Image recognition, speech recognition, AlphaGo Zero, and autoregressive large models are all examples of general learning methods beating human prior design at sufficient scale.
Architecture Is Feature Engineering
Jacob compares architecture to feature engineering. Today engineers specify the codebase structure, services, core interfaces, and abstractions, and agents find solutions within those boundaries. Engineers' input falls roughly into three categories: correctness feedback on code, context the agent cannot access, and judgment about the future impact of a design. The first will shrink as models get smarter; the second can be solved with better context and explicit guidance; the third is called judgment or taste and is hard to internalize because agents do not have signals like operational impact, the pain of scaling code, or CI impact.
His counterquestion is: if we can build systems to solve these three categories of problems and give agents all the information humans have accumulated, why should humans still be involved in architecture design? Architecture choices come from experience, and experience does not have to belong only to humans. A system that can explore more alternatives, observe consequences, and learn from those consequences might discover structures humans would never specify. The bitter part is that what gets replaced is the judgment senior engineers traded their careers for—and the source of what makes them consider themselves 'senior' and 'excellent.'
The Replies Are Sharply Divided
Someone responded directly with a video:
Roman says that maybe this has already happened, but no one dares let models make architecture decisions. Sharath thinks code layout may be possible, but real business rules like refund calculations will still be handwritten. Jacob replies: if you can prove with a black box that the implementation is correct and all invariants hold, why still handwrite it? Aleksandar's position is that this may be true for models, but for things that must be correct every time, handwritten checks still win. Alessandro puts it more sharply: half of clever abstractions are someone's ego. a says: let agents build, measure, and learn; without measurement there is no such thing as good code or a correct idea; engineers' abstractions are just bias.
The opposing side also brings up Sutton. Luca quotes Rich Sutton's tweet: brute-force computation is not enough to produce intelligence; smart new methods are needed, and AI science is far from done. Under this quote, someone responds with an image:
Michael asks a more practical question: what is the correct reward function, and what is the underlying substrate that continuously feeds and adjusts it? Aria thinks that custom lint as codified taste does resemble handcrafted features, but you can first delete style rules and keep those that catch real bugs. amois says they found they still need fences: when the system requires facts, inferred answers are unacceptable, and every value needs a named, checkable source. Meheryar brings it back to daily work: the skill of coaching juniors is now used on agentic harnesses, just with a different form of leverage.
From Writing Code to Designing Rewards
The latter half of the article compares engineering to reward design. Machine learning moved from designing features to designing losses and rewards; software engineering may move from handwriting systems to designing reward systems that let agents optimize their way to the right abstractions. The difficulty is that rewards are multidimensional, time-dependent, and hard to quantify, and they differ by company and even by team. A feature team may optimize for speed, while an infra team optimizes for scalability and security. A more general reward might be some quantitative metric of the codebase that makes shipping extremely fast while also being correct, secure, reliable, and scalable. Whether it looks like a system designed by a staff engineer should not have weight.
Engineers will not disappear tomorrow. The more likely change is that the center of work keeps moving downstream: from writing code yourself, to guiding agents to write good code, to building guardrails that ensure agents write good code, to constructing feedback loops that let agents discover for themselves what counts as good code. What will be truly scarce are the people who define measurable goals, design feedback loops, and leave the necessary guardrails. As for 'taste,' once it cannot be measured, it easily becomes style; once it is measured, it may just be a bias that has not been updated yet.
发布时间: 2026-11-18 15:28