Originally published on hayatibis.dev, where the figures move and the toys are interactive.
Illustrative. Thousands of scattered lines settle into a file, and one head goes straight to the right line, as if it had an O(1) index. (interactive version)
There were colleagues I looked up to, technical people. When they walked us through a case, they would take you to the right line in maybe 15,000 lines of code, as if they had an O(1) index: “Let’s look here in the code, there’s definitely something there.” The whole flow was settled in their head. We’d think, wow.
I feel we’re slowly moving away from that.
One head was never enough either
Knowledge used to live in at least one person’s head. That wasn’t really right either. When that person was on leave, busy or just not around, we spent extra time trying to understand the problem. Or when they left the company, we knew more or less where things were, but never as well as they did, and we lost some understanding along the way. It was harder than usual, but it got done somehow.
So we chased better processes. As CMMI puts it, a systematic way towards the outputs of the process improving the process itself.[1] We tried to move knowledge out of one head and make it the team’s: with docs, review, pairing and tests.
We still have the big picture, but it’s blurry
Today agents write most of the code. We still know the big picture: what the services do, roughly where the data flows. But the picture has gone blurry, and keeping command of it has become harder.
Illustrative. The same twelve files, four ways of knowing them. One head can point to the line; when it’s on leave, everything takes longer. The team spreads it with process. When agents write the code, the services are still clear and the lines blur. Writing why the code is there into the harness, as tests, ADRs and checks, brings the line back into reach. (interactive version)
This week I read two pieces on this, and in both I found what I’ve been thinking too.
Half the work was safeguards
The first is a post on X by Tarık Güney, an engineer at Microsoft, written in Turkish. He describes a problem he sees in the people he advises: they don’t feel as valuable as they used to. He points out that this isn’t new. When the Stripe API came out, the engineer who had gone deep on payments lost some of their edge; when jQuery and React came out, so did the one who knew the DOM inside out. What we feel with AI is the same thing at a much larger scale.
The part that stuck with me, in my translation: what engineers missed is that for years, more than half of what they did when building software was guarding against the mistakes people can make.
Clean code, CI/CD, abstraction, garbage collection: in his view all of them were, at the end of the day, there to reduce human error and make the work easier. So the safeguards we took against people’s mistakes yesterday, we need to take against agents’ mistakes today. That’s also where he points people asking about their careers: treating agentic coding as an engineering problem, and building confidence in the PR.
Under it he also suggested quitting social media. I agree: social media’s “software engineering is over, nobody needs developers anymore, anyone can do anything” hype does psychological damage, so it’s better not to take it too seriously. Thinking about where to focus and how to grow your career makes more sense.
I think along the same lines. The processes we chased were safeguards too: so not everything hung on the index in my colleagues’ heads, and we wouldn’t lose that extra time when someone was on leave or got something wrong. Someone else writes the code now, but those safeguards are still needed, and we’ve been building most of them for years.
Built isn’t working in production
The second is a piece on martinfowler.com by Rachel Laycock, CTO at Thoughtworks. Her question: why are good developers so wary of agentic development? The easy answer is that they love writing code, or worry about their jobs. Laycock says that’s true for some, but there’s something else behind it. Nearly every system we have in production was built the old way, by hand, by people we could trust. We haven’t lived with one built the new way yet. The wary ones aren’t hesitant to use an agent; they’re hesitant to take their hand off the wheel. It’s like going to autonomous driving after years of driving with your foot on the gas and the brake, always correcting the wheel by reflex: will we feel at ease, where and how will it take precautions, or am I going to crash?
My favourite part is an experiment. A team at Thoughtworks spent a week where nobody wrote any code and agents built everything. About two thirds of their time went to the whiteboard: working out the domain, drawing boundaries, making plans the agents could act on. The other third went to the harness: tests, contracts, architecture checks and a delivery pipeline. In her words, “Most of the work at the keyboard was directing agents to put this learning into the harness”, so they’d get it right on the next run.
The application ran, but the build was often red. “A red build should mean something: stop, investigate, fix it.” She asks: “If it’s red so often that people stop paying attention, how do we spot the next real failure?” And “if we can’t trust the checks, a green build stops being reassuring too.” Her summary fits in one line: “Built is not the same as working in production.”
Illustrative. The same stream of builds as agents commit. Red so often that people stop paying attention, and the next real failure hides among the rest. Red that means stop, investigate, fix stays rare, and a green build is reassuring again. (interactive version)
I think what Tarık calls safeguards and what Laycock calls the harness are the same thing. This site has a small harness of its own: the rules for the writing and my corrections live in an AGENTS.md and a log, and if a phrase I don’t want reaches published text, a test fails. The agent learns from them every time.
Breathing room
We need breathing room. I used to have a practice: on some Mondays I’d get to the office at 06:00 and sit down to read a solution I’d worked on maybe two or three months earlier. Two or three months later was a good time to look at how I’d been thinking when I wrote it. My cache was cleared, and I looked at it with different eyes: is this code really understandable? If I couldn’t follow my own code while reading it, the problem was big; expecting someone else to understand it by reading would have been shameful.
That also made room for cosmetic updates to the code. We’d take a breath and, without changing behaviour, try to make it more readable, more modular, with less cognitive complexity. Most recently we tried to do this in Go with lefthook and gocognit,[2] aiming to measure and reduce cognitive load with rule-based static analysis.
gocognit’s own example, from its README: the same function scores 4 with if / else and 1 with switch. The behaviour is the same; the second is easier to understand, so it scores lower. (interactive version)
With agents writing code this fast, I think these breaks matter even more. And a check like gocognit is already part of the harness: whoever wrote the code, it catches a hard-to-read function in the hook.
“That’s not how you do it”
I’ve been doing this for nine or ten years. Among developers there was always a crowd that didn’t like anything. Everyone talked back and forth about everyone else’s solution, playing “that’s not how you do it, this is how”. It was a silly war that put the “in my opinion” side of the work first. Plenty of it played out between developers with big Twitter followings too, and I think it was pointless.
Because what was valuable was always the same: software that always works, works correctly, and is designed so you can keep adding value on top of it. Not whose solution was more elegant.
Give the same job to N different teams and you could get M different solutions. Architecture decisions, language choice: the Java people, the Go people, the Node.js people, the ones writing JS on Node and the ones writing TS, the “let’s use a broker” camp and the “no broker, let’s do Redis” camp, the “man, why Postgres, let’s go MySQL” crowd, and so on. It smelled a bit of fanaticism, too. People also wanted to stay in the stack they knew. That wasn’t a bad approach, really, but forcing an SQL database where Mongo would have done well was unnecessary all the same. Shipping fast with a startup mindset to land a seed round is another topic. For a project that will live a long time, we’d rather move with a more manageable process, keeping it on a plane with fewer architectural changes or more manageable refactors, than spend effort trying to climb out of spaghetti later. Of course, it was always like this.
Looking back, I think most of those arguments were about taste, but some of them stood on a real question. The real work was telling the two apart. Two illustrative examples: a product catalogue where every category has different fields lives naturally as documents, and Mongo is at home there. The tables that hold orders and payments need transactions and consistency, and there a relational database isn’t up for debate. Brokers are the same: if several services read an event and you may need to replay it from the start, a broker is a need; if it’s a short-lived job queue between two services, Redis is often enough. The right question wasn’t “which one do we like”; it was the shape of the data, how much consistency it needs, and how long the project will live.
Illustrative. Give the same job to five teams and you get five stacks. Here the language doesn’t decide it; the shape of the data and how the messages are read do. (interactive version)
I don’t think staying in a familiar stack was something to wave away, either. Being able to write a language is one thing; knowing where to look when it fails in production is another. The “let’s look here in the code” moment at the start of this essay is exactly the second one. So the best outcome of those arguments wasn’t the winning side but a short ADR that wrote the decision down with its reason: six months later, when someone asks “why MySQL?”, the answer sits in the repo, not in one person’s head.
With agents writing the code, the sides of that war scatter a bit :) Often there’s no code owner left to argue “in my opinion” with, and the talk moves to two questions: does it work, and does it work correctly? The answer comes more from tests and checks than from one person’s opinion.
Back to those colleagues
That “let’s look here in the code” moment hasn’t gone away, I think; it has moved. The agent finds the line and brings it now. But something has to know why that line is there: a test, an ADR, a check. It used to be one person’s head that carried it; now the harness can, as long as we still look at it when it goes red.
In your codebase, where is the first place an agent wrote that you couldn’t point to and say “there’s definitely something there”? Or is it everywhere? Just some places? :)
Stands on
- Mark C. Paulk, Bill Curtis, Mary Beth Chrissis, Charles V. Weber, Capability Maturity Model for Software, Version 1.1 (CMU/SEI-93-TR-024) (1993)
- Tarık Güney on X (21 November 2026, in Turkish)
- Rachel Laycock: Why are good developers so wary of agentic development? (martinfowler.com, 29 October 2026)
- uudashr/gocognit: cognitive complexity of Go functions (GitHub)
- G. Ann Campbell (SonarSource), Cognitive Complexity: A new way of measuring understandability (version 1.7, 29 August 2023) (2023)
- evilmartians/lefthook: Git hooks manager (GitHub)
Notes
- The idea is the definition of level five in the SEI’s Capability Maturity Model (1993), CMMI’s predecessor: “Continuous process improvement is enabled by quantitative feedback from the process”.
- gocognit “calculates cognitive complexities of functions (and methods) in Go source code”, in its own words “a measurement of how hard does the code is intuitively to understand”. Its rules come from G. Ann Campbell’s Cognitive Complexity white paper at SonarSource. lefthook is a Git hooks manager.
A new essay every Sunday: get it by email. If you'd like more of these, you can support the writing on Patreon, or buy me a coffee once.





Top comments (0)