AI makes it dangerously easy to feel productive.
You open your editor, ask a model for a "quick" feature, and ten minutes later you've got a whole subsystem. Tests. Docs. A config file that looks suspiciously like it was invented on the spot. It feels like progress because your Git diff is huge and your brain is getting that nice warm "I am shipping" buzz.
Then you deploy it and realize you just built a large batch. With extra steps.
Small batches are a discipline, not a tooling speed bonus
Lean Startup small batches aren't about being cute or minimal. They're about learning. One assumption, one change, one signal back from the world.
AI makes the "one change" part cheap. That's the trap. Cheap changes pile up fast, especially when the model is "on a roll." Now you've got ten changes in flight and no clean read on what moved the metric. Or whether the metric moved because you broke something and users bailed.
I saw a version of this in a physical product company I worked for. They had a successful crowdfunding campaign, a genius programmer behind the product, and then he used the fame to land a FAANG job. That left a crater where the software team used to be, and I walked right into it.
Physical products punish big batches in a very literal way. If you order the wrong parts, you don't patch them. You stare at boxes of expensive regret. We learned quickly: don't pre-order parts based on vibes. Feedback had to show up early, or we were just building a nicer failure.
Software is kinder. It lets you ship a big batch and pretend you can clean it up later. AI makes that self-deception faster.
I don't need AI to prove that to me. I proved it myself years before any model existed, at a web design firm whose whole purpose was furthering the CEO's political career. We built pro-bono sites for politicians, including a senator who had a guy who literally followed him around opening doors and shaking people's hands for him. Firefox had just come out, and I'd jumped on it immediately - new tabs, extensions, the whole thing. Great browser. One problem: I stopped testing in Internet Explorer, which at the time still had most of the browser market. On a Friday, I got a bug report on a client's e-commerce site, mid-launch weekend, and did what every programmer has done at least once and regretted forever: I said I'd "just patch it real fast." Skipped the tests, skipped the IE check, shipped it, closed the ticket, went home.
The patch worked perfectly in Firefox. It took the entire site down in Internet Explorer, during the one weekend that store actually needed to make money. That's a large batch of exactly one line, deployed with zero validation, at the worst possible time. Small batches aren't just about keeping changes small. They're about keeping your test coverage honest even when - especially when - you're moving fast and it's Friday and you're sure it's fine. I learned to always test like a user, not like the browser I happened to be using that week.
The large-batch death spiral looks modern now
The old version was months of work, giant release, everyone panics.
The new version is one programmer, one model, one weekend, and a feature cannon that fires faster than your ability to aim.
I picked up a contract with a services company to build an AI system to improve accuracy. The idea was straightforward. The danger wasn't the ML. It was scope creep dressed up as "momentum." Once you can generate code faster than you can validate it, you start collecting features like souvenirs. Each one feels small. Together they turn into a blob you can't reason about.
If you've ever worked under a CEO with a cult-of-personality thing going on, you've seen how this gets worse. People stop asking questions because questions slow down the vibe. I'm allergic to that. I ask too many questions. It makes meetings longer and systems better.
Small batches need somebody willing to be annoying on purpose.
Use AI for tiny experiments, not giant "solutions"
The best use of AI in product work is shrinking the loop from assumption to evidence.
A tiny experiment has:
- One hypothesis
- One change
- One metric
- A rollback plan
If you can't say what you're testing in one sentence, you're not testing. You're decorating.
Here's a pattern that holds up:
- Write the hypothesis in plain English.
- Ask the model for the smallest code change that could test it.
- Add instrumentation before you ship.
- Ship behind a flag.
- Watch the metric.
- Remove it if it fails. Fast.
AI is good at steps 2 and 3. Humans still have to do step 1, because step 1 is where we negotiate with ourselves and call it strategy.
Let AI write tests like it's getting paid per bug
One of the highest ROI uses I've found is test generation.
Not "write me tests" in the abstract. Give it a job with edges:
- "Generate unit tests for these edge cases."
- "Create a regression test for this bug report."
- "Write a smoke test that hits these endpoints in this order."
- "Build synthetic QA paths that mimic a real user flow."
Then run them in CI and treat failures like useful bad news. Annoying, but useful. Like finding out your API silently returns null instead of throwing an error.
If you want a concrete workflow, here's a simple one:
## small batch checklist
git checkout -b exp/checkout-copy-variant-a
pytest -q
## ship behind a flag
## monitor metric: checkout_completion_rate
## decide in 48 hours
The tests are the boundary. If the model spits out 400 lines of code and you don't have coverage, you didn't ship a small batch. You shipped a mystery.
Keep the "boring" tools in charge
AI is not version control. AI is not release control. AI is not your incident response plan.
Use normal software for:
- Git: what changed, when, and why. Git and source control remain essential even when AI writes the code.
- CI: repeatable checks that don't care about your mood. AI-generated code still needs to earn the deploy through proper CI/CD gates.
- Feature flags: small exposure, fast rollback.
- Monitoring: you need numbers, not vibes. Vanity metrics look better when AI generates them, but they still don't tell you what's working.
- Issue tracking: otherwise your AI-generated work becomes archaeological debris.
I've written overly clever systems before. I once built custom BI software in C++ for a Fortune 500 company, including a custom encryption algorithm to pass database creds across machines. It was fun. It was also a great way to burn time solving a problem that already had a dozen boring solutions.
AI will happily help you do that again. Faster.
Keep batch boundaries human
The human job is restraint.
Deciding what is "small enough to learn from" is taste. Saying no is taste. Knowing when a fast patch turns into a future disaster is taste. Models don't have taste. They have settings.
I want small language models on phones. I want small, specialized models solving boring problems like Jetson-sized GPUs bolted onto little manufacturing rigs doing useful work. I also want Halloween decorations with robotics and AI that are actually creepy instead of "pressure pad makes skeleton yell." I have no shortage of ideas.
Ideas aren't scarce - validation is.
Use AI to tighten the learning loop. Don't use it to inflate the backlog.
-Sethers