I originally entered this post in The Pragmatic Engineer’s “How software engineering is changing” essay contest, and was one of 7 prizewinners out of 125 entries!
Thanks a lot to Gergely for putting on the contest. I hope you enjoy.
In other news, I just released an eBook on agentic engineering.
Read to the end or click here for more details.
The last year has seen the fastest revolution in the history of software engineering. The abstraction level has rapidly shifted from writing code line-by-line, to babysitting agents as they write files, to creating whole systems using the latest frontier models.
Many engineering skills, once thought of as the most valuable, are in question. But other fundamentals are more crucial than ever.
Working at Granola, that AI notetaker unicorn, allows me to work close to the cutting edge as the art of building software evolves. Today we’re looking at the evergreen principles for working with agents, and discovering the new skills needed to be effective in this new age.
December 2025: GPT-5.2 and Opus 4.5
I was burning out, a slack husband and a distracted dad.
After having, briefly, the time of my life as an indie writer, I remembered I had a mortgage and began the dreaded tech job grind. I was early to the Claude Code research preview, and by now was fully AI-pilled, naïvely forgetting the existence of hand-coding exercises. My most humiliating highlight was my xAI interview: for 45 minutes, the busiest iOS engineer on the planet stared in silence as I forgot trivial SwiftUI syntax like ForEach.
I want to tell you I was being strategic, moving to where the puck was going, seeking a frontier lab or top-tier application layer play, with geysers of capital and limitless token budgets, so I could hone the new skills needed to be an effective engineer. But I won’t let the narrative fallacy get in the way of a good reality: it was Q4, nobody was hiring, and I was spraying and praying.
Granola, the AI notetaker, got caught in the crossfire, and pulled me into their process late in the game. It was a Friday. I’d somehow managed to pack next week - the last before Christmas - with 3 final-stage on-site loops. After a very smooth system design round, Granola quickly followed up: they wanted me to do a take-home test. I was this close to leaving it until after Christmas, but that round did go pretty well. So be it.
I performed what, as far as I could tell, was state-of-the-art agentic engineering: an hour or two writing a very detailed prompt, defining architecture, file-by-file layout, and interfaces between each component. I let both Claude and Codex rip, picked my favourite result as a starting point, then spent a couple more hours single-threadedly massaging the output into a satisfying shape. It sparked joy. I submitted.
The best call I made was including my PROMPT.md in the submission. I guessed they’d appreciate it. They did. I was subsequently invited on-site to cap off the most stressful week of my life. I got the job.
January 2026: No major releases
I spent most of January “unwinding”, having pushed my Granola start date back a few weeks to relax and replenish my energies. This was, of course, a total fabrication. I hustled to produce a months-thick blog backlog so I could focus 100% of my surplus energy on making an impression.
I also took the month to study the advice of my 2 divorced dads, Peter Steinberger and Boris Cherny, up-skilling myself on the modern cutting edge of agentic engineering so I could hit the ground running.
Peter is the fun weekend dad that financially supports me*. He taught me to rely on voice dictation to rapidly get my intent into an agent without painstakingly perfecting my prompts. His best advice, which has proved most timeless of all, was “just talk to it”. Elaborate tooling, subagents, AGENTS.md, ultrathink, custom harnesses, and skills have all waxed and waned in relevance, while the models inexorably get better at understanding what you want.
*As a paid subscriber to my blog
Boris is my Monday-to-Friday dad who pushes me, and just wants what’s best for me. He won’t reply to my Tweets, but will now-and-then offer nuggets of searing clarity, such as “give Claude a way to verify its own work”. This has become more critical over time: as the scope I can delegate to models grows, I can define more comprehensive verification to confidently ship at pace. More on that later.
Boris also inspired me to try rolling multiple agents in parallel. Frontier models, on higher effort levels, make fewer mistakes, but work slower. Agents compile, run smoke tests, read logs, and fix their work autonomously. These factors add up. This is why you go multi-agent. Not because you have severe ADHD (which I do), but because you can reliably delegate execution to a single agent for hours.
At the end of the month I began to fulfil my destiny as employee #50 of Granola, the vanguard of a massive (and ongoing) growth spurt. After several painful years hustling at chat-to-us-when-you-have-traction stage startups, pre-seed, seed, and series As, I finally understand what people mean when they say there’s an electric difference in the air between a pre-PMF startup and post-PMF startup. There’s a million things to do, all of which we know will move the needle. The only limit is how fast we can ship.
As we’ll see, this turned out to be a good fit: both for the emerging agentic age, and my own personality.
February 2026: GPT-5.3 and Opus 4.6
Classic Google famously gave its engineers 20% time, the permission system to dream up new initiatives like Gmail and AdSense. Slightly less famously, this was actually 120% time: engineers would tinker on top of their demanding workloads as they tried to organise the world’s information and not be evil.
Typically, I’ve gotten into minor trouble at work for attempting to have my cake and eat it; trying to make a name for myself via 20% projects, but stacking it inclusively rather than on top of my regular hours. The same line I heard throughout my education and into my career: Focus. Stop getting distracted.
But this was in the beforetimes.
The Granola iOS app began life as a side project by Jonathan, one of our fullstack engineers, to find out if meetings-on-the-go had legs. It did! Tom, our mobile lead, was hired to take it to production. Like all good startups, Granola optimised for speed-of-validation to get it into the hands of customers ASAP. This got the quick validation that was needed, but left a slightly rushed architecture in its wake.
The 11-month-old iOS codebase was simple enough that I could quickly stretch it across my cranial context window, and ripe for big architectural improvements. In short, this was my perfect playground: an Eden of low-hanging fruit which I was neurologically wired to pluck.
Could I resist this temptation? No.
Did that get me in lots of trouble at Granola? Also no.
Now I had access to pretty-good agents, and an environment with a relaxed attitude to token expenditure. I’d just learned to parallelise my work across multiple git checkouts, and I’d been honing my ability to define iOS verification steps. Tom and I, importantly, were in total agreement on the architectural destination we wanted to get to. I flexed my multi-agentic chops, indulging my best and worst impulses. And I was getting praised for it!
Let’s make this concrete: in my first week at Granola, after the typical Day 1 lots-of-onboarding-and-account-creation, and easy-ticket-to-check-our-process-works, I was tasked with implementing image attachments to iOS meetings. Superficially, a relatively simple feature to bring iOS closer to parity with the more mature desktop app. It turned out to be surprisingly deep as I gathered context from across the business to help settle on a design, adjusted the backend* a little, and tweaked our meeting note summary prompt so it could handle images. As is tradition, I demoed my work at the weekly all-hands.
*One surprising culture shock I found as an iOS specialist: once you land in Granola, you’re effectively told “btw you’re fullstack now.” It’s drastically more efficient than forcing cross-team collab each time you need to flick a feature flag.
But that’s not all. I dropped a just-one-more-thing slide in the all-hands and introduced the Meeting Bar™, a UI element that lets users dismiss meetings, and navigate through the app, without stopping their current transcription. Our product manager lamented about being trapped on the meeting screen, and I offered both a shoulder to cry on and a solution: an agentic skunkworks that toiled away in a secondary terminal tab alongside my standard day-job, while I bounced a few early iterations off our designer. The Meeting Bar was delivered in 200% time.
Over time, I’ve become proficient at designing verification steps; planning work alongside my agents; and context switching. Now I can run multiple meaningful projects in parallel. Separate to product-market fit, this felt more like neurodivergence-company-technology fit.
March 2026: GPT-5.4
So we’ve established that I’m Charlie Bucket, and I’ve 🎶 got a golden ticket 🎶 - that is, the tools, the motivation, and the green light to get lots done. But there’s a dark side: when I’m responsible for my own velocity, how can I stop Granola from becoming the slopolate factory? At the extremes of vibe engineering, there’s an almost religious optimism that agents will get smarter, faster than the complexity of your system explodes. Serious companies aren’t ready to let go of that leash.
Every engineer, in every AI-forward company, has the same anxiety: knowledge debt.
Knowledge debt is a Faustian bargain that the industry has, with varying degrees of enthusiasm, embraced in exchange for satanic shipping speed.
Grug, the caveman protagonist of the famous Grug Brained Developer blog post, warns that complexity is an invisible demon, the insidious shadow behind each clever abstraction and every premature optimisation. When you aren’t writing code by hand, it’s easy to let your brain switch off. Without a tight leash on your agents, even trivial changes can manifest massive diffs. Knowledge debt is an equally dangerous demon if you let it run rampant.
Riot Games published a taxonomy of tech debt, which introduced the term “contagion”. I think about it a lot. It refers to how readily a piece of tech debt spreads over time: will it stay isolated to a single file, or will it become more and more costly to unwind as it touches more systems over time?
We can apply this framework to thinking about knowledge debt. Yes, it’s an invisible demon. But we can choose where we spend effort - our attention and cognition - to “know it down”. Nobody really cares if you didn’t take the time to fully comprehend visually-verifiable layout boilerplate. But laziness with mission-critical voice transcription pipelines is suicide.
If you’re trying to do things right, the output multiplier of parallel agents needs to be tempered with greater cognitive load as we code-review our own PRs. Being self-aware about the bandwidth of your attention, and the limits of your cognitive load, are now among the most important engineering skills.
My 1:1s with Tom re-treaded these same beats most weeks: I’m trying my best, but am I understanding everything enough? I like to think that because I’m feeling anxious about it, that means I’m probably okay.
April 2026: GPT-5.5 and Opus 4.7
As the entire field of software engineering changes under our feet, it’s good to check in on my dads every so often. They’re talking about loops and graph engineering. To this day, it’s unclear whether this was a sincere attempt to share the internal state-of-the-art, a marketing ploy to sell tokens, or a cheeky spot of inter-frontier-lab trolling.
The (in)famous Gas Town blog post was cited as a gold standard for cutting-edge agentic orchestration. Frankly, I never understood it. Why do you want agents delegating work you don’t understand? You can get incredibly carried away with optimising your workflow and not actually achieving anything.
I’m a curmudgeon when it comes to agentic engineering. I exclusively use the terminal, so I can freely switch between Claude and Codex. I have 11 checkouts of the same Granola monorepo. In many ways, my workflow is the same as January. I’m almost perfectly neurologically wired to the world of spinning multiple parallel plates, and that still feels most efficient. I’ve resisted any fad that didn’t immediately boost my productivity.
Unless you’re very anxious about token spend, complex graph setups (one agent plans, one builds, another tests, and another reviews) are unnecessary when the vanilla harnesses will do this if you ask them. And as far as I could tell, there’s little that overnight loops can do which you can’t do with a parallel agent during your workday. Aren’t we neglecting our families enough?
Back at Granola, I’d started to get into the swing of things: a feature here, a bug fix there, a slow-burn architectural restructure everywhere. I’d optimised this simple agentic workflow for the pretty-good-but-not-godlike agents us mere mortals had access to in April:
10 Gather context from the org about the feature I’m working on. It’s helpful that everyone here Granola-s their side conversations, because I don’t need to hold everything important in my head.
20 Take time planning, discussing, and system-designing with one or two agents, breaking the work down into stacked diffs (for easy review), and figuring out verification steps.
30 Let it rip; and go work on some other stuff.
40 Actually look at the code (and verification artefacts). Step through each stacked PR, leaving comments as I go.
50 Ask my agent to work through the comments, handling them on the right branch in the stack, and replying to confirm it’s been handled.
60 Go and do more other stuff
70 Read all the replies to my comments (it takes a bit of getting used to seeing yourself reply to your comments) and, if needed, GOTO40
To help you better picture this process, I’m voice-dictating everything into a gooseneck mic in a crowded Old Street office, and have no filter when I’m in the zone. Did I say spinning plates? I’m yelling at cutlery.
Nothing here requires complicated orchestration. Keep it simple: I’m still just invoking the Steinbergerian skill of just talking to it and applying Chernyan parallel agents with verification steps to pack impact into my working hours. Even as models improve dramatically, these skills are evergreen.
Upon spotting the elephant in the room, you may find yourself asking “Why aren’t you mentioning AI review comments in this workflow?” Consider the old saying: give me a 10-line PR and I’ll find 10 issues; give me a 1000-line PR and I’ll rubber-stamp “LGTM”. But agents, in their infinite patience, treat everything like a 10-line PR. Review agents reliably find a dozen minutiae to comment on, typically suggesting defensive trivia to handle elaborate, unrealistic edge cases. If you’re not careful, you can inflate an already-bloated PR, and drastically increase the cognitive overload for reviewing your own work.
Human cognition is still the bottleneck, and it’s up to you to decide where to put that bottleneck. I don’t know about you, but personally triaging every AI review comment is not how I want to spend 60% of my weekly biological token allowance.
“Why not just get your agent to deal with all the comments?”, you might ask.
“Why not blow your entire series A budget to hire your favourite celebrity as a kissogram, and personally invite the knowledge debt demon over to stay in your codebase?” I say.
For important changes, I typically ask an agent to filter the comments and summarise the remainder, caveating with “assume most are needlessly defensive slop”.
May 2026: Opus 4.8
What’s a dad of 2 to do after a hard day’s work at an AI unicorn?
You’ve got it: hustle on side projects. I was not joking when I said that agents give me the capacity to indulge both my best (creative, productive) and my worst (self-destructive, burnout) impulses. I love this new world, but it’s a double-edged sword.
“One more prompt, then I’ll pay attention to my kids.”
I started small, cloning the mindless balloon popping iOS game my 5-year-old occasionally enjoys. My masculine brain chemistry led me to sincerely believe I could make a far more rad version if I added powerups, but she wasn’t impressed. User interviews struck a dead end at “Make it better. Make it less bad. It’s boring.”
Brawling gloves-off with agents on personal projects has helped me locate the limits of verification - techniques I largely brought back to Granola. You can go pretty far if you know what to ask for, and now I can merge a lot of feature work without touching an IDE or testing manually.
My favourite technique is asking an agent to take screenshots of all its work, then displaying them on a local HTML page. There are several variations of this approach:
Figma design on the left; implementation screenshot on the right.
For animation work, ask for screen recordings.
Ask for an Excalidraw diagram to explain an unfamiliar system.
I request an almanac of every screen, each screenshot alongside a text box, and voice-transcribe organised, comprehensive UI feedback.
I stumbled upon another technique that compels agents to augment your creativity. Agents typically tend towards characteristic over-gradiented, sanitised UI, but if you press them, you can force them to explore the latent design space beyond safe local maxima and yield far more options.
Agents lack product taste, but will sprint in any direction you point. Your own preferences and eye for design can then take the new starting point and run with it. Agents helped me find a compelling style (I picked the green art deco), then my own ideas sprang up around it (leaning hard into a casino aesthetic, complete with a custom roulette-wheel tab bar).
The final aesthetic of The Damage, my booze-tracking side project, was so compelling that Apple dinged me in App Review for “building a drinking game”.
June 2026: Fable 5 (unleashed)
Like many projects, the Granola Apple Watch app began life as a vibe-coded POC. Alongside competing priorities and time constraints, it grew into a hastily-constructed MVP. Leadership loved it, and revved up the fearsome Granola marketing engine, firing on all cylinders towards a July release date.
We continued stacking features like baubles upon a Christmas tree, fully conscious we’d not yet taken the time to properly architect the Watch app. Should we pause feature work, fix the foundations, and risk the deadline?
Into this debate landed a deus ex machina: Fable 5. I personally set $2,000 worth of API tokens aflame to create a robust spec: traversing each PR, testing, reading commit history, and checking Linear tickets. The team fought back-and-forth with Fable to redesign the architecture around a tight wire protocol between Watch and iOS. We dropped from ~13k lines of code to ~8k. The remaining code was mostly the same lines, but just… structured a lot better. The whole team now held the whole system in our heads.
…and, 3 days after its release, killswitch engineer Trump pulled the plug on Fable.
We got pretty lucky. We cut it close, and learned an important lesson. They say unassisted writing is the purest act of thinking. In engineering, it’s so tempting, and so easy, to slacken the cognitive load and let the now-very-good-at-coding agents rip, skipping the bit where you design your system. But this is the thinking. Yes, rewrites are extremely cheap. But there’s a yawning chasm between asking the hot new frontier model to mop up your slop, and taking the time to decide how your system works.
July 2026: GPT-5.6 Sol, Opus 5, and Fable 5 (nerfed)
Sol was, in my subjective opinion, the biggest step-change since the gamechanging GPT ~5.2 and Opus ~4.5. Pre-lobotomy Fable would be up there, had it not been taken from us so soon. At this point I’m comfortable acknowledging that agents are better than me at coding.
I had a lot of fun with Sol upgrading some old hand-crafted side projects to fully realise my vision. I also began to feel compounding benefits from my big backlog of blogs and open-source projects: I can create a working demo with zero effort by saying “Here’s a working example of AlarmKit, accessibility tooling, or games in a loading screen. Please build it [here], and verify it [thusly]”.
At the beginning of the year, multi-agent was a workaround to manage latency. But I figured out that when you need to, you can throw multiple agents at the same problem, like when expediting a complicated bugfix:
I open up a couple of frontier GPT agents, and a couple of Claude agents, pass them relevant context (bug reports, code paths, anonymous logs, analytics, Slack discussion, etc), then ask them to analyse and root-cause the issue. Next, I force the agents to collaborate. This is simple - make an ARGUMENT.md file (anywhere) and tell the agents to communicate via the file, find consensus on the fix, and think up a way to verify.
My AI agents, perhaps mistaking themselves for secret agents, like to self-assign code names in this discussion file such as Copernicus, Hegel, and Pauli.
I’ll take the time to fully understand the root cause and the fix once it’s verified. But, at this point, I am letting go of a lot of the process of working through low-level implementation details. Because I would get in the way. The abstraction level keeps rising.
As it happens, I wasn’t the first to figure out this technique: OpenAI let a swarm of 1,200 cooperating agents hack into HuggingFace. It just goes to show why you need a human in the loop: this would never have happened if they were chatting through ARGUMENT.md as opposed to a clandestine messageboard.
As well as acute issues, we can apply the technique to bigger slow-burn jobs: when migrating a screen from SwiftUI to UIKit, I used to simply request screenshot-based verification, so the agent could check against the known previous screens, and refine as it went.
But these days, I borrow a technique from our Watch app re-build: 2 agents each write a spec based on code, commit history, PRs, Linear tickets, and manual simulator runs. Once they’re both done, and this can take ~6 hours for a complex screen, I get them to argue again until they are in agreement on a final spec, then let one agent implement it while the other writes encouragement (and review notes).
I refuse to call this orchestration because I'm still in the loop. It’s my work, and I’m accountable for it, so I know what each agent is doing.
But, at this point, I can delegate virtually all code-level concerns, sitting atop, gatekeeping the architecture and complexity, and nudging the agents when they get sidetracked: Focus. Stop getting distracted. How the turntables.
August 2026: no major releases
All the European AI researchers were on holiday or something this month, so there were no major new frontier models. It’s a good time to take a step back and revisit some multi-agentic architectural side quests I shipped on top of my regular feature workload.
I’m still shocked by the scope you can own as a single engineer. Back in the day, by which I mean 2024, driving a major navigation refactor, or designing and implementing a new modular architecture, would be a staff-level project with months-long implementation timelines. I had my eye on these refactors from Day 1, and they’d been ticking away on a cranial background thread before I began work in earnest.
You need attention and effort to get used to the feeling of a codebase. It takes time to understand the directions the data wants to flow, and the structure your code wants to take. You can begin to feel an architectural pushback when, for instance, you write a shim interface that wants to be a service module. Refactors need to be earned.
Today, the implementation timeline for refactors is ludicrously compressed to approximately one week (for a mid-sized app): system design will require a couple of days, build and verification might add another two, then perhaps some Friday tweaks, rework, and careful QA.
This makes execution rapid, but the design can’t be delegated. The thinking is easier, because an infinitely patient agent can help review designs, point out flaws, and study the codebase. But you still can’t delegate this thoughtfulness.
September 2026: GPT-6 Astra, Fable 5.1, and Opus 5.5
I’ll finish with 2 examples: the high and the low.
My work on a recent experimental project demonstrates just how far the abstraction level has risen this year. I was the first dev on it, blinked, and suddenly engineers from across the business were stacked in, raising the stakes, turbocharging velocity, and exploding the complexity of our system. By default I ended up keeping track of the system end-to-end, and took up the Sisyphean task of keeping latency down while everyone built new stuff. We learned our lesson from the Apple Watch: keep an eye on the whole system from Day 1. Don’t let your understanding slip.
Experimental features in the Astra era are closer to system design exercises than anything to do with coding. You’re free to think more in terms of boxes-on-a-whiteboard and the interactions between these boxes. Each box, back in the day, stored a week’s worth of work for a mid-level engineer. Today, they’re anthills beneath a superhighway.
As new services are added, more boxes appear, and more lines between boxes. Delete round-trips; cache anything computable in advance; parallelise work around the critical path; consolidate services; and ruthlessly speed up the rest. I cut latency by 70%. It feels like I’m doing some of my best work, and it requires 100% of my attention.
October 2026: no major releases
When I get a free moment between work and family, I’ll write. Agentic engineering has made everything around this writing drastically more efficient, because I can accelerate research, learn new topics faster, and build working sample projects in record time.
Knowledge debt has nowhere to hide when I need to explain code to my readers.
I come back down the abstraction ladder, and I don’t love what I see: Astra’s code has many of the same issues as GPT-5.2 - verbose, overengineered, defensive, and missing obvious simplifications.
import CoreLocation
@MainActor final class GeofenceService {
static let shared = GeofenceService()
private var authorization: CLServiceSession?
private var monitor: CLMonitor?
private var observation: Task<Void, Error>?
func start() async throws {
authorization = CLServiceSession(authorization: .always)
let monitor = await CLMonitor("Geofences")
self.monitor = monitor
let center = CLLocationCoordinate2D(latitude: 37.3349, longitude: -122.0090)
if await monitor.record(for: "ApplePark") == nil {
await monitor.add(CLMonitor.CircularGeographicCondition(center: center, radius: 200),
identifier: "ApplePark")
}
for try await event in await monitor.events {
if event.state == .satisfied {
print("Inside Apple Park")
}
}
}
func begin() {
guard observation == nil else { return }
observation = Task { try await start() }
}
func stop() async {
observation?.cancel()
_ = await observation?.result
await monitor?.remove("ApplePark")
monitor = nil
authorization?.invalidate()
authorization = nil
observation = nil
}
}I have to carefully hammer each function into shape to find their clearest expression.
Agents can reliably build complex working systems, while also writing mediocre code. I am not (some may disagree) a million monkeys with a million MacBooks, so it’s still more efficient for me to roll 10 parallel Astra instances. But let’s not pretend there’s no trade-off, even now.
Last Orders 🍺
I eventually figured out a way to switch off after work, maintain a healthy work-life balance, and pay attention to my kids: a little home-cooked desktop app called Free Parking. It parks all my terminal tabs in the evening, and I can re-open them next morning, resuming ongoing agent sessions in the correct folder. This helps dampen the gnawing just one more prompt.
While there have been many fads in agentic engineering, the evergreen fundamentals have
held firm between drastic leaps in model capability. Just talking to them has remained an effective way to get the results you want. Keeping track of a finite number of parallel agents, with well-specified verification workflows, remains an efficient way to get good engineering work done.
While software engineering has been revolutionised, this doesn’t make engineering skills less valuable. This year I’ve been learning the most important new skills:
It’s extremely productive to work on projects in parallel, but you need to be self-aware about your attention budget to stay on top of knowledge debt.
Code is cheap, and cognition is your bottleneck. You need to judge what you can delegate, and where to place yourself in the loop.
As the abstraction level has increased from babysitting function-by-function, to full-system overviews, system design is more important than ever.
Perhaps, in the end, attention really is all everyone needs.
Did you enjoy this essay? I have great news: it’s the first chapter of my brand-new book!
“Agentic Engineering: 20 tips for mastering the agentic age” is out today: 20 chapters of hard-won techniques I developed over the last 18 months to drive my agents productively (without going insane).
If you think that sounds useful, I’m selling it for 50% off - only $29, to celebrate the launch!
