If AI writes most of your code, what does it mean to understand it? Marc Brooker, an engineer at AWS who works on safety for agentic AI, has a sharp answer: stop trying to understand every line, and start understanding what the system promises. We think understanding AI-generated code starts there, and we learnt it the hard way while building Calendrz.
What Marc Brooker argues
In “What does it mean to understand what we built?”, Brooker responds to a recent manifesto against AI slop, which lists “understanding over speed” among its values. He agrees with the spirit, but not with where the manifesto points it. Most of the document is about code, and Brooker thinks the goal of understanding code is, in his words, “holding us back from understanding what matters.”
His point is that the things people care about are properties of the whole system. Some are precise (“a SELECT never shows results from uncommitted transactions”). Some are fuzzy (“makes the user’s life easier”). Neither lives in any single line. Some behaviour, like the metastable failures he knows well from large distributed systems, only appears when the parts interact, and you won’t find it by reading them one at a time.
He compares today’s practice to engineers “looking at each screw, each grain of aggregate, and each PCB trace” to understand a bridge. Anyone who has built an IKEA wardrobe knows the feeling: you can check every last screw and still end up with a door that doesn’t close. His call to action is short: “It’s time to look up.” AI, he argues, finally gives us the tool to do it.
Understanding AI-generated code at Calendrz
Calendrz is built by a very small team, and AI agents write a large share of the code: about two thirds of the commits in our repository carry a Claude co-author line. So Brooker’s question isn’t academic for us. And reading every line an agent writes, with the care you’d give your own, doesn’t scale.
What we do hold on to is the handful of promises Calendrz makes. The main one is simple: when you’re busy in one calendar, that time is blocked in every other connected account, and it stays in step with the original. Move a meeting, and its block moves. Cancel it, and its block goes. Nothing private leaks along the way. That is availability mirroring in one sentence, and it is a system property, not a function.
Earlier this year we found out what it means when such a property quietly breaks. Creating new blocks worked perfectly, so everything looked healthy. But when someone rescheduled or cancelled a meeting, the block in their other calendars stayed exactly where it was. Each line of the code involved read sensibly. Two checks compared an event’s unique identifier with something that looked similar but wasn’t the same kind of value (an email address in one case, a calendar’s identifier in the other), so they never matched, and the update was skipped without a sound.
Why didn’t the tests catch it? Because they exercised the first pass: a brand new block, with nothing to compare against. The bug only lived on the second pass, when the block already existed. Reading the lines didn’t find it. Asking “does a moved meeting move its block everywhere?” did. The fix itself was tiny; the lesson was the property. We wrote the root cause up, added tests for the update path, and in the same review tidied up a couple of neighbours, such as renewing calendar change notifications before they expire rather than just after.
The same pattern, again and again
The other properties that matter to people using Calendrz look much the same: every connected account’s access keeps working, not just the first one; a calendar that disappears on Google’s or Microsoft’s side doesn’t break the others; your Profile never shows anyone the details of a meeting, only that you’re busy. None of those is a line of code. All of them are things we can state, test and ask an agent to defend.
What to take from it
- Write down what your system promises. A few sentences, in plain English, that you’d stake the product on. That list is the spec, and it outlives any version of the code.
- Test the second pass, not just the first. Creating something is the easy path. Updates, moves, cancellations and retries are where properties break.
- Let the agent read the lines; you own the promises. Ask it to show how a change keeps each property true, and to write the test that would catch it if it didn’t.
We’d go one step further than Brooker. The future of software engineering is a “lights out” setup: people describe the system through specs and properties, and agents write, test and ship the code. Understanding doesn’t disappear in that world. It moves up a level, from the screws to the bridge.
If you juggle several calendars, the promise you care about is the simple one: book a meeting anywhere, and you’re busy everywhere. Try Calendrz free and let auto-blocking keep that promise for you.







