In February 2025 I was looking for a book that I could give to my developers, so that they would know how to write tests. With that in mind I reviewed the draft of the first volume of Angry Tests, a book about tests by Yegor Bugayenko. I did not agree with everything in it, and while reading it I got the idea to write a book of my own. I did not know how much I had to say, and I worried that it would end at 20 pages, too thin even for a small handbook. So I hoped for at least 100 pages, and I planned about three months of work. The work started in Claude Code on 29 November 2025, so by that plan the book would be done around the end of February. Instead Laminar Software Design became 277 pages and went live on 31 August 2026, after nine months of work instead of three. So where did those nine months go?
Why a book of my own
The book really began with what I did not agree with in the draft of Angry Tests. Much in that book is good: tests that reproduce a bug before the fix, no mocks, isolated and fast tests, good names and failure messages, and a catalogue of anti-patterns. Still, some ideas I was looking for were not in it. And some of its key concepts played badly in my practice, one of them more than the others.
The concept that worked worst for me is overlap, which treats many tests failing after one change as a good thing, since more failures carry more information. The second volume of Angry Tests states it openly: many failing tests “help me triangulate the root cause faster”. The same idea was already there in the draft of the first volume that I reviewed. My own projects are enterprise ones, with millions of lines of code and many teams. There a hundred red tests after one change end in a revert, or in changing the tests blindly until they pass. In that setting nobody triangulates a hundred failures, so the extra information only annoys the developers. Instead of going deep into a hundred broken tests, they look for a way around them.
From that disagreement came the idea of my own book, a single reference for everyone who works with me. With it I would not repeat the same explanations in every review of a pull request. I imagined it as a handbook or a field guide, which new people could read first. At that time I worked on a migration from SAP Commerce to microservices, so my first idea was a book on microservices, which I tried in the summer of 2025. Over that summer I saw that this scope made the book too narrow for what I had in mind. Narrowed to microservices, it was becoming an aging practical guide that was focused on the wrong thing. What I wanted instead was to explain a universal approach to software design, which holds whatever stack a team uses.
How the writing started
With the universal scope decided, the work in Claude Code started with a plan. Before that I had talked about the book in a chat app. On 29 November 2025 I gave that conversation to Claude Code as the basis for a work plan. The first table of contents followed the book Clean Code by Robert C. Martin, because it is a bestseller in the industry, but I was not happy with it. So the same evening Claude interviewed me about my views on software design. For the structure I still wanted to compare the topics of other books, because “publisher, author, reviewers spent a lot of time deciding this things”. From that interview came a new plan with five parts, and what was left was to fill them with text.
How to fill them decided the way of writing in the first months. I wrote the main ideas of each chapter, the logical chains from one idea to the next and the facts that support them. Claude expanded them into readable prose with correct grammar. When I planned this post, I described the result as “a structure of ideas and transitions between them, which then were extended to be readable as prose”. Then I read what Claude wrote and changed it, mostly by hand. By early January the first six chapters of the plan had been written this way, and Claude had reviewed each of them for the order of its ideas and the links between them.
I kept the ideas and the reading with me because at the start of the book I did not trust AI output at all. In software development AI works inside a feedback loop: it writes code, runs the tests, starts the real application to check the change and adjusts the code. Even with such a loop, in early 2026 I could not trust AI output and had to recheck all of it. Still, code at least has that loop, and a failing test points at what is wrong.
A book in my own voice with real facts has nothing like that around its text. No test tells me that a sentence still says my idea, or that a fact in it is real. So at the start of the book the only check was my reading, and that is where most of the time went.
Where the time went
Reading as the only check
Since only my reading could check the text, the split between my work and the work of Claude changed slowly. Over the months my share of writing by hand became smaller, but the roles never turned around. When I prepared this post, I put it this way: “it never flipped, just amount of writing constanly decreasing”. By the end my work was reading, writing notes on what was wrong, letting Claude rewrite a passage from a note, and reading the result again. For a change of one or two paragraphs I reread the rewrite as a suggestion before it went in. After a larger rewrite of a whole section I reread the section once the change was made. What never became smaller was the reading itself.
What that reading looked like is easy to see in Chapter 1 in January, which I went through note by note. I read the chapter and wrote my notes, and Claude evaluated them, critiqued the chapter section by section and checked its facts for the first time. On the busiest day of that work I sent 433 prompts, almost all of them about Chapter 1, and the last of them went out past three in the morning. The evening before, I had asked Claude whether one paragraph of the chapter repeated another one. In the same prompt I already doubted my own eyes: “I reread that too much and everything mixed up in my head.”
That reading went beyond single sentences, and it remade the structure of the book as well. The plan of five parts from the interview still leaned on other books, and it did not last long. Already the next day, while I planned Part 2, I wrote that there was “no big sense to rely on existing suggestion for part 2”, and from there the plan became my own. The next large change came in January with Chapter 6. I read it again, decided that it was “trash, so I removed it”, and wrote it anew. From February to March chapters were split, merged and removed, until on 28 March the book settled at 12 chapters in five parts.
Over the whole book the same kind of work filled 199 days, spread over nine months. Counted as the time between prompts, it adds up to about 860 hours in the sessions. On top of these hours came the reading outside the sessions, which no prompt records. A full reading of the book took me about ten hours, and every chapter I read 30 to 50 times. So by my own estimate the reading outside the sessions took a few hundred hours more.
Text that reads well but says something else
What all this reading caught is easiest to see in February, and the first case was my own choice of the title. From 1 February I searched for a title among software words. On the second day I wrote to Claude “I’m already lost and tired” and asked it which title from the research would sell best. On 3 February I settled on “Isolevel Software Design” and wrote it into the book. That evening I generated the pages of the book, saw the new title on them and did not like it. So I stopped looking in software words and looked into math and physics instead. By the next morning I had “laminar”, a flow in smooth layers that do not mix.
Right after the title changed, I asked Claude to spread “laminar” and its opposite “turbulent” through the chapters, so that a reader could learn the new words. First Claude researched how readers learn a new word, and the spreading followed that research. Chapter by chapter the text still read well, and no single sentence looked wrong. That afternoon I read it as a reader would and wrote down what that reader asked: “Author why physics? Why laminar? … Why I need to learn it?” Read this way, the new words mostly replaced “good” and “bad”, and they broke the flow of the text. In the evening I reverted the first changes and started a second pass that added as few new words as possible. Less than an hour into it I wrote “I’m doing it totaly wrong”, and asked whether it was better to stay with good and bad without all this physics. By the next morning almost everything was reverted, and only my reading as a reader had shown that the text, which read well, said something else.
What the word lacked was a meaning, and that meaning had to come from me. Over the next month I worked it out level by level in my prompts, and Claude wrote each level into a concept file of the book. In Chapter 1 laminar means code that is simple, correct and fast enough, like a flow that wastes no energy on swirls. Chapters 3 and 4 add the layers: levels of abstraction that do not mix, each moving at one steady speed inside. Later chapters add the speed at which a smooth flow turns turbulent, and then the Reynolds number, which decides whether a flow stays laminar. The last chapter adds that code left alone turns turbulent, and only steady effort keeps it laminar. Each time a level was clear in my head, the word went into the chapters again, but only where it added something new. This time it stayed, and all six meanings are in the printed book.
Checks before reading
My reading catches such a pass only after it is made, which is why checks that run before I read mattered, the way tests run before a code review. Some of them were older than that February pass. The first were style rules in files. After them came a script that counted the words in each sentence, written in early January. On 26 January the rules and the script went into a style skill, a set of instructions that Claude Code loads when a task needs it. The skill never started on its own, even when a task clearly needed it. So I called it by hand, about 700 times over the book. Even so the violations went on, and in July a rewrite came back with short sentences again, so I asked Claude “Why you are not follow writing style rules?”
Rules like these measure the form of a sentence and cannot tell whether it still says my idea. My notes on the text already lived in files, one note per point and grouped by chapter. On 10 February I asked Claude to work with them in another way: “Show me current text, my note, your analysis … And we would work one by one.” For every note Claude showed the whole paragraph with the sentence at issue, my note in my own words, its analysis of the note and a recommended rewrite. Only after my answer did a change go into the book, and I kept that way of working until the end. Over the book about 1,300 notes went through it.
A word could also change its meaning slowly across the book, which neither the rules nor a single note could see. So in April I started a glossary of the book, which today holds 211 entries, and 56 of them guard against such drift. In May came Vale, a linter for prose, which checks words and terms by fixed rules and gives the same answer every time. The word “level” shows why both were needed. It meant a level of abstraction, but in some sentences it slipped into the meaning of scale, and in May I wrote to Claude “In one case we use level in aother scale”. In August a Vale rule was written for that word. I cannot measure how much Vale helped, but subjectively I saw fewer low-level wording issues.
Behind all these checks the only reader was still me, because every result of them came back to my reading. So in July I made a clean copy of the book for an outside review by AI. The copy held no notes and no decisions, so the review knew nothing of what I had decided. In August I went through its findings one by one, and about one of them I wrote “that’s really a critical bug”. The review also cost a lot, because it ran as 9 parallel agents on the usage limits of my subscription. When I planned it in July, I wrote that the “9 parallel agents … eat all limits and none finishes”. And it missed things that its own review plan said it should find.
An outside reader judges the text and not the facts, and until August the facts rested mostly on me. They came from the books, papers, articles and blog posts I had read, and from my memory of them. So in August I created a skill that checks every claim of the book against a local copy of its source, the book, paper or article itself. That check never accepted an abstract or the memory of the model as a source.
The local copy itself could be wrong. Some old books and papers exist only as scans, and their text came through OCR, a program that reads the text from the image of a page. One evening the fact-check reported that the book was wrong about one such source, although I clearly remembered that the source said the opposite. I asked whether it had also looked at the image of the page, because “ocr can lie”. The page image settled it: the OCR had read the text wrong, and the book was right. Out of that case came a rule: every OCR source got a marker, and every check of it got a look at the page image.
The checks needed checking
The fact-check and the reviews were AI output too, and I trusted them no more than the text, so they needed my reading as well. The worst failures came in August, when Opus 5 had been the default model of Claude Code for my subscription plan since 24 July. It is the first model whose output I later came to trust with loops around it, and yet the checks on it failed. In one run of the fact-check the AI swapped two local copies of sources, so it read one source while it believed it was reading another. It then proposed a “one-character fix”, which would have moved a correct citation onto a source that does not support it. In that run of 9 August, 6 of about 45 findings did not survive a second reading. In the run of 22 August, 6 of 27 significant findings were overturned. Even on Opus 5 these failures were caught by the loop around the check, which read every finding a second time.
A change applied without asking me was worse than a wrong finding, and in August I found three of them in four days, on the same Opus 5. The first was a fix from the fact-check that gave up my argument about an example from a book of Kent Beck. I wrote back: “Why you applied change without prior confirmation with me? I don’t like it and previous were better.” Two days later Claude again applied changes before I had seen them, and I wrote: “Why you hae applied anything without my approval. Return back.” Since then nothing is applied before I approve it.
Decisions as memory
A rule like “approve first” helps only if the next session knows it. Claude Code loads CLAUDE.md and memory files at the start of a session, but they hold only what someone has written into them. So the book got a decision log, where every judgment I made became a written decision with its reason. By the end there were 602 of them, and most of those with a date were written in July and August, during the reviews and the fact-check.
Among them the most useful are the dead ends. One of them was written in March and records the spreading of “laminar” and “turbulent” in February as tried and reverted. With it came a rule: use the words only where they add something. Without that decision a fresh session would sooner or later propose the same change again as a good idea. Developers keep architecture decision records for people who join a project later, and here every new session was such a newcomer.
The cover
Not all the time went into the text, and the cover took more of it than I expected. When the work on it started in Claude Code on 7 April, six versions of it already existed, and none of them felt right. On 7 April I wrote “Lets fully change our direction and fully redesign everything”, and the seventh version became the cover. It shows five lines that turn from red chaos into parallel teal, the laminar flow of the title. Claude draws it with code, which writes the cover as a vector image and sets the width of the spine from the number of pages. Even there a small request could go wrong. When I asked to connect two lines, Claude changed much more, and I wrote “You ruined everything. Return back.”
The real problems of the cover showed only on paper. On the first proof copy the red part of the lines felt dim, and the name of the author looked faded. On the second the word “laminar” came out too big and too bold, so I kept both versions to compare them with the printed copies. Four adjustments followed the first print, and the last of them came on the day the book went live. In the sessions about it, the cover and the text on its back took about 44 hours over 15 days, and the first six versions are not counted in that.
When to stop
Even with all the checks and decisions, every finding still came to me. On 22 August two sessions ran side by side on the findings of the reviews, and for hours I answered both of them in turn. When one of them proposed a rewrite of a passage, I answered: “Rewrite just make everything worser and blurry”. Nobody else read the drafts in full, and only my wife read the first chapters, which need no technical knowledge.
In the end the doubt I had in January came true: I had reread the text too much. When I looked at a page, I already knew everything on it before I read a single word. My eyes slid over the lines, and my head filled in what it expected to find there. To review the text at all, I had to force myself to read it word by word. Even then I saw what I remembered more than what was written. One study of proofreading found a similar effect: students found fewer errors in their own essays than in a familiar essay by someone else, because they knew their own text too well. Stephen King advises in On Writing to put a manuscript away for at least six weeks, until reading it feels “like reading the work of someone else”. Every new reading only made me know the book better, so I published it when I could no longer read it.
On 26 August the 277 pages went to KDP, the publishing service of Amazon for books and ebooks. On 31 August the paperback and the Kindle edition on Amazon and the ebook on Google Play went live on the same day.
From writing to building loops
The checks and the rules I built for the book did not stop when the book was done. In October the skills for writing the book became a plugin of their own. In November a blog skill made from them rewrote this post on its own. I still read the result, and I was not sure that I liked it.
So that is where the time went: AI took away the empty page and gave me hundreds of hours of reading in exchange. The reading was needed, because at the start nothing but my reading could recheck AI output in my voice. Most of the book was written on the models from Opus 4.5 to Opus 4.8, and Opus 5 came only for its last month. Even there the loops and their verification were what caught the failures. Opus 5.5 has been the default since 22 September, and the trust I have now comes from Opus 5 and Opus 5.5 together with the skills, verification and feedback loops built during and after the book. And I still read anything that has to sound like me. So my work with AI moved from writing to building loops and reading what they let through.
If you want to check the result, a free sample with Chapters 1 and 2 is on Amazon and Google Play, and the links are on the book page. I would be glad to hear where the book is wrong.
The numbers
All numbers end on 31 August 2026, when the book went live. The work after that was for the next edition.
- Span: first prompt on 29 November 2025, live on 31 August 2026 (Amazon shows the Kindle edition on 2 September).
- Prompts: about 16,500 in the book folder, short approvals included, and a lower bound, because prompts sent through remote control are not always recorded.
- Days and hours: 199 days with work, about 860 hours in the sessions, and reading on top, by my estimate 300 to 500 hours.
- Busiest day: 12 January 2026, with 433 prompts.
- Pages: hoped for at least 100, first proof 252, final 277, about 85,000 words.
- Cover: seven versions, the seventh printed and then adjusted four times, about 44 hours in the sessions about it.
- Decisions: about 600 written decisions with their reasons.
- Style skill: called by hand about 700 times.
- Models (the Claude Code default for my subscription plan) and their share of the prompts: Opus 4.5 to early February 2026 (22%), Opus 4.6 to mid-April (34%), Opus 4.7 to late May (12%), Opus 4.8 to 24 July (17%), Opus 5 from 24 July for the last month of the book (16%). Fable 5 was chosen by hand for the outside review.
- Subscription: $20 Pro until November 2025, $100 Max from November 2025, $200 Max from July 2026, so $100 x 8 months + $200 x 2 months = $1,200 at list price until publication, without tax. The same subscription also ran my other projects.
- Other costs: two ISBNs at 45 euro each, four proof copies before going public at about 25 euro in total, about 5 euro for a copy and 3 euro for its delivery.
- Sales: 19 copies so far, mostly bought by people I work with.
P.S. AI did a large part of the drafting, the rewriting, the source reading, the reviews and the builds. Ideas, structure, examples and every decision are mine. The copyright page of the book says it directly: “In preparing this book, the author used generative AI tools as drafting assistance. The author directed the writing, reviewed and revised every passage, and holds full editorial responsibility for the content.”