I've been developing software for 25 years.
For the last two, I've been writing code almost exclusively with AI.
Recently, I signed up for the next @ship30for30 cohort by @dickiebush and @Nicolascole77
Which immediately raised the obvious question: what am I going to write about for 30 days?
One option was to write about things I've already figured out — essentially, teach my two-years-ago self what I know today.
But I realized I'm much more interested in writing about the problems I'm dealing with right now. Things I haven't figured out yet.
And that gave me an idea.
I keep noticing dozens of small things I could improve in my AI-assisted software development workflow. Better instructions. Better tools. Better context for agents. Better review loops. Less manual work.
Most of them sit in the "I'll get to it someday" pile.
So why not turn Ship 30 into an experiment?
For the next 30 days, I'll focus on improving my AI-assisted software development workflow.
Every day, I'll do at least one of these:
- implement a small improvement;
- reflect on what worked and what didn't;
- try a new approach;
- ask other people how they solve the same problem;
- watch or read something and steal a useful idea.
And every day, I'll write a short post about what I learned.
My hypothesis is simple: 30 small experiments should leave me with a significantly better development workflow than I have today.
And perhaps the process of getting there will be useful to someone else too.
The challenge starts Saturday. I already have a few ideas for the first posts.
After that, we'll see where it goes.
Follow along, subscribe, ring the bell, smash that like button, etc.
Mostly, I'm curious whether I can outrun my ADHD — the part of my brain that, approximately two weeks into any project, starts slamming on the brakes and looking for some shiny new concept to obsess over.
1
268
3 ways to check if immature features are clogging your product pipeline
Shipping like crazy, but barely moving the needle? Maybe you should build less instead.
You can ship a new feature in a few days, but maturing it still requires the feedback cycle that takes weeks.
It’s nearly impossible to foresee all the ways customers interact with your product. Every feature needs to mature through real-world usage, feedback, and iteration. The less mature the feature is, the less value it brings. If a user tries it and it doesn’t work in his context then he’s likely to switch to a competitor.
If you do not pay attention to feature maturity, your product gets bloated with half-baked features nobody uses. That was a problem long before AI came in. But AI made it much more severe.
Picture your Kanban board with two extra columns after Done: Immature and Mature. AI speeds up your way to Done. But features pile up in the Immature column.
Here are the 3 ways to check whether you’re falling into this trap:
1. Check feature adoption
Ask your favorite AI agent to build a list of features shipped in the last 1-2 months.
For each feature ask it to calculate and evaluate:
- Activation rate (% of active users that tried the feature).
- Retention rate (% of users that use the feature on a regular basis).
(AI should have access to your GitHub, DB, logs or analytics to build that report.)
It’s hard to judge numbers without context, but if less than 5-10% of your active users even try the feature then it’s not clear whether you should’ve built it at all.
2. Check feedback from users
When you launch a feature, do you get any incoming questions, suggestions or complaints?
If you don’t then either you’re a product genius and you hit the bullseye every single time or nobody is actually using it.
More often than not it’s the latter.
3. Check your intent
When a user churns or doesn’t buy on a sales call, is your first thought "We need another feature"?
If the last ten features didn't improve your metrics, why would the next one?
The fix
If you find yourself in this trap then the best you can do is stop digging. Instead of building, it’s better to talk more to your users and figure out the disconnect between the last ten features shipped and what these users need.
2
1
44
How non-technical Product Owners can pre-vet features with AI (before bothering the dev team)
Product owners come up with brilliant ideas. But without a deep technical background, some of those ideas might not be trivial to implement, to say the least.
Typically, a PO has to ask a senior engineer whether the feature is even possible and what other parts of the product could break.
For example: A PO wants a report showing total monthly revenue. But in the database, the ‘amount’ field is optional. Now he has to decide: Do we show an asterisk explaining incomplete data, or make the field mandatory and backfill older data? A PO won't even know this problem exists until an engineer opens Claude and asks about the feature.
So why not let the PO ask Claude directly?
To do this, give an AI:
- Read-only access to your repository
- Read-only access to your staging/production database
- (Optionally) Access to your task tracker
You can deploy this via a local Claude setup or through a custom-made Slack bot.
Then create a skill that reads a feature idea, scans the code and the data, and interviews the PO in plain English.
Use the following prompt to generate the skill:
Create a skill for non-technical product owners who bring a feature idea or tracker card. Without changing anything (read-only code, SELECT-only database queries, no personal data), check the idea against the real code and data.
Look for hidden dependencies: reports, exports, emails, permissions, integrations, billing, existing data, and everything that reacts to an existing thing the idea says it should "work like".
Play the idea back, give a one-screen first verdict, then interview the PO one numbered question at a time in plain business language: what's true today, why it matters, and options A–D with a recommendation.
Never ask technical questions. Go blockers first and keep going until every blocker and conflict is decided or parked. Offer reshape, phase, pay-for-it or drop-the-edge for anything expensive.
Then draft a card (story, behaviour, acceptance criteria, side effects, out of scope, open questions, plus engineering notes) and create it in the tracker only after an explicit yes.
The result:
- The PO gets instant feedback instead of waiting for the senior dev to get back from his vacation
- The engineering team receives a feature description that is clear of obvious landmines
- Poorly thought-through ideas get shot down before they reach the dev team
46
4 ways to build a product on a limited budget (as a non-technical manager)
AI dramatically changed the way we build software. But that doesn’t make it free.
If you are a non-technical manager trying to build an internal tool or an MVP, here are the 4 setups I see most often and their trade-offs.
1. Vibe-code it yourself
When you’re willing to get your hands dirty.
- Upside: The cheapest option if you have spare time
- Downside: Steep learning curve. You’ll spend dozens of hours figuring out how to set everything up and you’re still likely to mess up the codebase past the point of recovery.
2. Contract a mid-level dev full-time
When ‘merging a PR’ sounds like a magic spell to you and you’d rather keep it that way.
- Upside: Frees you completely from technical details
- Downside: He’ll end up acting as an AI operator on your behalf. Without senior architectural judgment he’ll accept whatever AI throws at him resulting in endless back-and-forth and a buggy implementation.
3. Contract a senior-level dev part-time to build stuff
When you still want to delegate, but you’re tired of constant rework and want a seasoned approach
- Upside: Less back-and-forth and rework, maintainable code
- Downside: Progress can feel like watching a pot boil
4. Vibe-code + consult a senior-level dev
When you want to build it yourself, but keep getting stuck in endless rework loops.
- Upside: You still get to be the builder with someone to stop you from digging yourself an architectural grave.
- Downside: Slower pace. Still need to learn the basics of CI/CD, testing and system design.
The verdict
Building software on a limited budget is always a compromise.
But here is my take: I see little value in hiring a full-time mid-level dev on a small-scale project.
You’re better off hiring a part-time experienced dev who actually knows how to design the system, set up the foundation and enforce the best engineering practices.
If you’re willing to spend time and learn how to build a product yourself then consulting with a seasoned dev pays off in the long run.
What setups have you seen in action?
2
1
151
Can a non-technical founder build a high-quality product using an AI software factory without a senior engineer?
My answer is no. Here’s why:
The software factory, the way I envision it, requires a skilled developer to review all specs and PRs. It speeds the process up, but cannot substitute for engineering judgment.
However, it is possible to reuse the underlying principles.
The most important one: observe the current process to eliminate unnecessary work.
A typical situation: a founder writes requirements and hands them over to a part-time mid-level developer. When the task is ready, the founder manually tests it, finds a dozen issues and sends them back. The developer fixes some of them, creates new ones and the cycle continues.
The copy-and-paste from an AI chat on one side to an AI chat on the other takes a lot of time and effort and is really inefficient.
A better workflow:
- AI writes a technical spec based on the requirements
- The developer reviews, edits and approves the spec
- AI implements the spec once approved
- AI reviews the feature the same way the founder does it (once the founder writes down an instruction)
- The developer is notified only when the PR is ready for review
Would that make the product quality solid?
Unfortunately, no. If the developer fails to detect a structural flaw in the spec or the PR, the factory won’t magically catch it either.
What it does is eliminate unnecessary back-and-forths and tighten the feedback loop.
3
131
Why you need an AI software factory (even if your team already uses Claude Code or Codex)
The activity I used to spend the most time on while building a product was:
Reviewing and fixing PRs.
A typical process looked like this:
- I ask Claude to build the next feature
- It submits a PR
- I review it, find a bunch of issues and ask Claude to fix them one by one
Addictive for developers like me, but really inefficient.
A better use of my time was to fine-tune instructions for the factory so it produces PRs that are good enough to merge without any rework.
Instead of pointing out to Claude that ListedCompanyCheck has no clear meaning in the context whatsoever, I added the rule ‘A name tells a cold reader what the thing holds or does’ to my coding guidelines.
Tuning a single PR does not compound. Tuning instructions works for every single PR that comes later.
So why not fine-tune the process locally?
In theory, you can. In practice, I put it off for weeks.
Only when I moved the process to the factory did something click in my head. I actually started thinking about how to spend less time improving a specific PR and more time on preventing these mistakes from happening again.
I bet this is what happens in your team as well. It’s inherently hard for a developer to stop playing around with Claude Code or Codex and think about the instructions.
Moving the process to the factory was the first step toward eliminating wasted review time.
1
59
Do not build a software factory unless you satisfy this crucial criterion
Before you build a software factory, answer one question: what’s actually slowing you down?
Yesterday, I was talking with a startup founder about whether he should spend any effort towards deploying a software factory. Our conclusion was: absolutely not.
He runs a B2B product for enterprises. The product is already good. The problem is that enterprise sales are slow. It takes him several months to get to a pilot, a few more to execute it, and no amount of development effort would speed that up.
Eliyahu Goldratt, the author of “The Goal”, says the only way to increase profit is to focus on the bottleneck.
Investing effort in building a software factory only pays off if:
The bottleneck is development.
Otherwise, a factory is like putting an F1 engine into a car that only drives in a 30 km/h zone.
1
35
Getting off the needle of interactive dev sessions
Switching from interactive Claude Code/Codex sessions to a software factory is painful.
It feels like going through withdrawal after quitting drugs. Here’s why:
Developers have been hooked on a specific dopamine loop for ages:
- Make a small improvement in the code
- Run it
- Watch it break
- Fix it and see it start working
It’s an insanely vicious cycle.
AI made this drug available for everyone. The internet is full of stories of non-technical founders staying up all night vibe-coding their app.
The problem with software factories is that they take away the joy.
Instead of chatting with an agent and watching code become better and better with every iteration, you have to refine instructions so the agent produces a clean PR on the first attempt.
It’s not nearly as fun!
I was aware of this problem and had to consciously stop myself from talking to the agent. It was similar to writing instructions for an employee, instead of telling him what to do every single time.
But it pays off – productivity goes up significantly.
By following this practice I was able to improve the rate of PRs merged without modifications from 30% to 75–80%.
12
5
217
How to launch an AI software factory in an afternoon
When you hear about someone shipping thousands of PRs a second, you imagine a sophisticated software factory process.
In reality, it doesn’t have to be that complex in the beginning.
Follow these 3 simple steps and you’ll have a basic factory up and running in hours, not days.
Step 1: Run locally
Connect Claude Code/Codex to your task tracker, GitHub, and your staging (or production) database.
Configure a basic pipeline:
- Analyze the task and prepare spec -> spec
- Implement & review -> PR
- Post-approval steps: ensure it gets merged/deployed, mark the task completed and send notifications
Review and correct specs and PRs. The factory will become more autonomous over time, but in the beginning, review should be fully manual.
Use your favorite skills to prepare the spec and to review the code. (I use superpowers brainstorm and my own pre-PR review pipeline, but for you it could be spec-kit and Claude’s default /code-review.)
At this stage, you should be able to tell the AI to pick the next card and it should execute the pipeline, and prompt you whenever it needs input.
Step 2: Run remotely
Move this setup to a VPS or a Mac mini. Launch sessions using ssh + tmux or Claude Remote Control.
This way, the pipeline keeps working even if your laptop or workstation is offline.
Step 3: Orchestrate
Write a simple orchestrator script on that VPS or Mac mini to:
- Poll your task tracker.
- Launch a new Claude Code/Codex worker session with a prompt.
- Impose work-in-progress (WIP) limits so it doesn’t try to burn through the entire backlog in parallel.
Add a skill to notify you via messenger or email when a spec or a PR is waiting for review.
TIP: The notification message should include a link to quickly open the session in the Claude app.
That’s it! You now have a working software factory. When a task is marked as ready, the orchestrator picks it up and hands it over to the agent to work on until the next review.
The next step is tuning the factory so it produces PRs you’re happy to merge on the spot.
3
189
[🛠️ Day 30/30] Overhauling my AI development harness: what I didn’t expect from 30 days of daily writing
The biggest benefit of going through this writing challenge is that I actually overhauled my AI development harness.
- Built my own software factory: increased the percentage of feature PRs merged without corrections 30% -> 75-80% and made 25% of factory PRs merge automatically.
- Improved instructions with evals: I figured out how to use evals to fix my pipeline every time I see a mistake in a PR.
Public commitment forced me to return my attention to the factory and make small improvements every day. I don’t think I would’ve stayed on the topic without the challenge and I certainly didn’t expect it to work out this way.
What I failed to achieve:
- Views/engagement: my posts got 150-250 views on average and were mostly commented on by AI bots.
- World acknowledgement of my wisdom and depth of thinking.
I’ll continue sharing my indispensable thoughts about software factories daily, but I’ll also write about other topics.
Thanks to Dickie Bush and Nicolas Cole for the updated “Ship 30 for 30” course.
40
[🛠️ Day 29/30] Overhauling my AI development harness: the 3 required properties to merge large refactoring PRs
Tackling tech debt usually requires refactoring.
Some of these refactorings are trivial, but easily 1,000+ lines of code. How do you let AI merge them automatically?
The ideal way is proving that the refactored code is strictly equivalent. Unfortunately, existing formal verifiers struggle with complex refactorings and are computationally demanding.
So what’s the second-best way?
I treat the code as equivalent if these 3 properties hold:
- No changes in tests: The PR touches application code only.
- 100% test coverage: Every changed line is exercised.
- Mutation testing in diff: Every meaningful introduced mutant is caught.
The first two properties can be checked deterministically.
The third is trickier. Deterministic mutation testing tools are too noisy and slow. Instead, I rely on AI to analyze the diff, predict which mutants are most likely to survive, and run targeted tests against them.
Until now, I’ve been merging 1K+ LOC refactoring PRs when these 3 criteria are green. Now I’m ready to let AI merge them automatically.
Since I already have an eval suite for my PR triage agent, I just ask Claude to:
- Find PRs that match these conditions
- Add them to the eval dataset (or relabel them to be merged automatically)
- Update the triage agent instructions to let them through
Another step up the ladder of trust toward a dark factory.
3
2
62
[🛠️ Day 28/30] Overhauling my AI development harness: the 5 things I check before merging an AI PR
On Day 23, I started making notes to understand how I review code.
My goal was to figure out how to reduce my review time.
After processing another dozen PRs, a 5-step checklist emerged:
- Object model: Do the proposed entities, their names and how they interact make sense to me?
- Test coverage: Is the code well-covered with tests and does mutation testing confirm test quality?
- Verification criteria: Do tests match the criteria in the spec?
- UI smoke check: Does the main flow work in the browser?
- Quick code scan: Is there anything in the diff that looks off?
I found it really inconvenient that there’s no way in GitHub to see what tests cover each diff line and click to quickly jump to a test. Nor to highlight caught and survived mutations.
Guess no reason waiting for CodeRabbit or Greptile to implement that. It’s easier to vibe code a tool by myself nowadays.
Let’s say you review a 500-700 LOC refactoring PR. How do you make sure it is well-covered with tests and is safe to merge?
1
1
41
[🛠️ Day 27/30] Overhauling my AI development harness: making your software factory produce PRs you merge on the spot
Developing an orchestrator and connecting it to GitHub and Slack is the easiest part of building a software factory.
The real challenge is to make agents ship PRs you’re ready to marry and live happily ever after.
The best way to do that is to tune the reviewing agent to follow your preferences.
Because if the reviewer catches an error, the implementer is likely to fix it automatically. It may use more tokens than it should because of the back-and-forth, but that can be fixed later. It is easier to build eval cases to test the reviewer than the implementer or the pipeline as a whole.
Every time I find something I don’t like during PR review, I create a case describing the issue.
The case contains a problematic commit hash and a free-text description of the error. The eval runner checks out code in a separate worktree, runs the reviewer and uses an LLM as a judge to see if the reviewer found the issue.
To create each eval case I follow these steps:
Step 1: Make it RED: ensure the reviewer without the fix misses the issue.
Step 2: Make it GREEN: tweak the instruction to make the reviewer pass the judge.
Step 3: Ensure it stays GREEN: the reviewer on the commit with the fixed code stays quiet.
I’ve created a skill to propose and run a case automatically when I tell the agent to fix something in chat.
These steps cut my PR rework 3x-5x over the last couple of weeks, as I described in my previous post.
2
2
74
[🛠️ Day 26/30] Overhauling my AI development harness: cutting PR rework from 70% down to 22%
There’s no good metric to measure development performance. Counting PRs per month is just as flawed as measuring lines of code.
So I decided to use a different metric: PR rework rate – share of PRs I had to send back.
Since the majority of my development time is spent on steering the agents, the share of AI-produced PRs accepted with no remarks during my review is a great indicator of improvement.
I asked Claude to build a report from GitHub. The share of reworked PRs plummeted.
- Features: dropped 70% -> 22%
- All PRs (including bug and tech debt fixes): dropped 51% -> 11%
That’s 3x-5x less rework!
Compare that to the manual PRs rework that stayed the same.
I attribute the drop to two important changes:
- Writing instructions instead of hand-holding agents: when I see a mistake in a PR I update factory prompts rather than fixing the PR in a chat with an agent.
- Inversion of control: agents pick and analyze tasks, prepare specs and then ask me to review, etc.
I definitely feel that I became way more productive working this way.
It’s satisfying to see the git commit history back it up with numbers.
PS: To calculate this metric just ask Claude: rework can be tracked by commits after the PR is opened or reviewed. Claude is smart enough to exclude rebases and merges from main.
2
1
88
[🛠️ Day 25/30] Overhauling my AI development harness: the overlooked prerequisite for a software factory
Imagine buying a brand new car from the dealer. You try to open the door and it falls off, because at the factory nobody bothered to check if it actually works.
This is exactly what happens if you ship software without tests.
Manual QA is unlikely to keep up with how fast AI builds stuff. So either it becomes a bottleneck or untested code reaches production.
A few days ago, I wrote that the best way to start with software factories is fixing tech debt.
While that’s true, I forgot that many developers even today ship naked code. It was easy for me to overlook because I’m a long-standing TDD fan.
My first attempts to write unit tests date back to 2003 when I read Kent Beck’s “Extreme Programming”. But to be completely honest, I only started following the practice meticulously in 2015 when I began building greenfield startup projects.
Tests are the prerequisite to auto-merging anything.
AI can only fix an error when a failing test signals what went wrong. Moreover, if test coverage is good enough, then all green means you can deploy safely.
To write good tests, the architecture has to follow dependency injection to isolate external dependencies. That’s easier on a new project, although an astonishing number of developers still ignore it. On legacy code, it usually demands some serious refactoring.
If you’re working on legacy code that doesn’t have 90–100% test coverage, the first step before even thinking about building a software factory is:
Refactoring for testability, then writing tests. That makes your doors open as they should.
1
38
[🛠️ Day 24/30] Overhauling my AI development harness: AI solves the problem you describe, not the problem you have
AI coding agents have a dubious habit: they do exactly what you tell them instead of questioning what you’ve described.
This morning, I was reviewing the spec Claude Code proposed.
A client reported that our AI agent didn’t use proper titles (Dr., Prof., etc.) on contacts imported from Apollo.
Claude Code generated a spec to fix the issue. But my manual review revealed two problems:
- The bug wasn't Apollo-specific: The exact same issue happened across every other contact source.
- AI didn’t think about this change in a larger context: The title should be editable and it could be read from a signature in a customer response.
Claude proposed fixing exactly what was written in the bug report and nothing else.
When a senior engineer analyzes a bug, he looks beyond what’s described in the ticket. He thinks about how the fix works in different contexts and affects other parts of the system.
That doesn’t mean AI cannot do the proper analysis. It’s just that nowhere in my pipeline did I ask it to.
This is why I’m reluctant to run AI unsupervised until the process is tuned to weed out these types of errors.
So let’s make some improvements: “Claude, please take a look at the session, notice it jumped straight to the spec skipping the analysis part. Propose improvements to our pipeline. Check how they work in an isolated subagent. Make no mistakes. 😁”
2
2
72
[🛠️ Day 23/30] Overhauling my AI development harness: to automate code reviews, I have to go backward
I want to double the number of PRs my software factory ships each day.
To do that, I have two options:
- Spend 50% less time reviewing each PR
- Let the AI auto-merge
To unlock either, I have to understand how I actually review PRs. And right now I don’t.
I do it intuitively: I glance at a diff, feel an urge to check something, follow that emotion, build a mental model in my head, figure out missing pieces.
It reminded me of the Four Stages of Competence:
1. Unconscious Incompetence: I don’t know that people even do that.
2. Conscious Incompetence: I know I miss bugs when I review PRs.
3. Conscious Competence: I follow an explicit checklist to thoughtfully review PRs.
4. Unconscious Competence: I review PRs like a rock star, but I have no idea how I do it.
A beginner climbs these stages from 1 to 4.
Automating code review requires doing the exact opposite.
When a professional dancer wants to start teaching, he needs to understand what makes his movements stand out. Return from stage 4 to stage 3. I need to do the same with my reviewing skills.
So I plan to note down my thinking process for the next few days to make it more conscious.
A quick test: can you explain how you review a PR? Without saying “I just look at it”?
3
2
100
[🛠️ Day 22/30] Overhauling my AI development harness: 3 questions to ask before letting your AI factory run lights-off
I still review almost every PR under a microscope.
Meanwhile, my timeline is full of developers bragging about shipping 2,000 PRs a month with barely any supervision. In manufacturing, they call that a "dark factory"—turning off the lights and letting the assembly line run fully automated.
So who is right? And how do you decide how much light to spill on your own production line?
Here are three questions to ask yourself before making a decision.
Question #1: How expensive are your mistakes?
The amount of attention to code quality largely depends on how much damage a mistake can do, and to how many people.
It also depends on how easy these mistakes are to detect and correct and how reversible they are.
If you’re the sole user then unless you’re building a robot to perform heart surgery on you, it’s likely that the cost of an error is not that big. The factory could stay dark.
If you’re building a payment system that processes millions of transactions daily then you’d want to make sure it doesn’t allow buying a Mercedes with a hundred bucks in an account. I’d rather spill some light.
Question #2: Do you find AI’s technical design skills good enough for your domain OR do you expect AI to become good at that pretty soon?
The problems I see with the object model that AI produces are that it:
• Is too literal
• Doesn’t compose well
• Leads to code bloat
It means that without the proper architectural supervision the codebase might end up in a state where AI spends a lot of tokens to understand code and is unable to ship features anymore.
I can be wrong, though. If you see that in your context AI provides good enough architecture or you have faith that AI will do that soon, then I see no problem going dark.
Question #3: What’s the expected timeframe for software development?
If the project is estimated to take less than a couple of months of development, then suboptimal architecture is unlikely to be an issue. So dark mode as well.
I still don’t trust the technical design AI proposes, and I work on long-term projects.
That’s why I’m going to release my grip slowly. I’ll review almost all PRs manually, fine-tune agent instructions as we go and turn off the lights for pipelines I begin to trust once I’ve seen AI do the right thing consistently.
1
1
59






