AI-First Software Development: Redefining How We Build Software

At Tembo, we've watched teams go from shipping a few pull requests a week to shipping dozens a day. AI pair programming moved from experimental to essential faster than anyone predicted. But here's what we've noticed: most development practices are still stuck in 2023, creating friction where there should be flow. Studies on AI coding assistants show measurable productivity and satisfaction gains, but they also surface new workflow bottlenecks.^[1]

The AI-First Software Development (AIFSD) Manifesto is our attempt to codify what's actually working for teams already living in this AI-accelerated world—11 principles that treat AI as a true development partner, not a fancy autocomplete.^[2]

The Core Tension: Generation vs. Integration

AI has revolutionized code generation. But it's also exposed a new bottleneck: moving generated code from concept to production. The adoption of AI-assisted coding has dramatically increased development velocity, with teams reporting 10x more pull requests. This shift has forced organizations to rethink their development workflows, particularly around code review and merge processes.

While generating initial code has become significantly easier, the challenge now lies in efficiently moving code from PR to production. The manifesto addresses this head-on.

The 11 Principles

1. Let AI write the first attempt

Think a little, and get the ball rolling. Be specific about what you want—vague prompts get vague code. But don't overthink it. Ready, fire, aim.

The best developers I know have shifted from "let me code this" to "let me describe this." They've learned that AI responds well to clear intent, and that it's faster to iterate on AI-generated code than to write from scratch.

2. When chat gets tedious, take the wheel

If you're copy-pasting code blocks for the fifth time, stop. Pull the branch, commit directly.

This principle recognizes the natural rhythm of AI collaboration. Sometimes the back-and-forth is productive; sometimes it's friction. Know when to switch modes.

3. You own the merge, period

AI is your intern, not your boss. You're responsible for what ships—act like it.

This isn't about AI replacing developers—it's about AI amplifying developer judgment. The merge button is still yours. The production incidents are still yours. Own it.

4. Tag team like pros

AI writes scaffolding, you handle the gnarly bits. AI refactors, you write integration tests. Back and forth.

The best AI-human workflows look like pair programming, not delegation. You're not handing off work—you're collaborating in real-time.

5. Speed > perfection (on iteration zero)

Get something working first. It's easier to reason about a solution with concrete code. AI excels at "make it work," you excel at "make it right."

Perfectionism kills momentum. AI lets you prototype faster than ever. Use that superpower to explore solution spaces, then refine.

6. Leverage async workflows

Automate bug reports, errors, and other alerts to generate PRs. If the AI has to wait for you to initiate, or your laptop must stay open for work to continue, you're a bottleneck.

This is where we're headed at Tembo. The best teams we've seen have agents working in the background while humans focus on architecture, edge cases, and decisions that actually require experience. When you close your laptop, work should continue.

7. Commit early, commit often—both of you

Small commits from AI, small commits from you. Git history should tell a story, not be a novel.

Atomic commits aren't just good hygiene—they're essential for AI collaboration. When things go wrong (and they will), you need clean rollback points.

8. Testing is still your job, not optional

It's easier than ever to have test suites—AI can draft tests well. But you need to decide what actually needs testing, and why.

With this principle alone, your software quality can go way up without costing you much, if any, time. AI writes the test boilerplate; you bring the domain knowledge about edge cases and failure modes.

9. Review everything like it came from a junior dev

Because it did. AI writes confident code that might be confidently wrong.

This framing matters. You wouldn't blindly ship a junior dev's code. Don't blindly ship AI code either. The review process is where human judgment earns its keep.

10. The human always has the last word

When in doubt, your judgment wins. AI suggests, you decide.

This isn't about distrust—it's about accountability. AI doesn't understand your users, your business context, or your technical debt. You do.

11. Domain knowledge is your unfair advantage

AI knows syntax and patterns, but you know why the business logic exists and what could go wrong in production. That context gap is where human judgment becomes irreplaceable.

Early AI adopters learned this lesson: the developers who thrive aren't the ones who write the most code—they're the ones who understand the problem space deeply. Syntax knowledge has been commoditized. Domain knowledge has not.

Why This Matters Now

Early AI adopters learned these lessons through trial and error. They discovered that traditional code review breaks down under 10x PR volume. They realized that perfect AI-generated code is less valuable than good code that ships quickly. They figured out that domain knowledge—not syntax knowledge—is now your unfair advantage.

The manifesto distills those learnings into something actionable.

The Bigger Picture

The manifesto positions AI as the ultimate junior developer: incredibly productive, but requiring experienced oversight. This framing preserves human agency while maximizing AI leverage.

We're asking for feedback because we're all still figuring this out. The principles will evolve as tools improve and teams discover new patterns.

If you're already living in an AI-first development world—or still experimenting—we'd love your input. Check out the manifesto and tell us what's missing. Better yet, PR your signature if you're in.

— Ry