AI Velocity Needs Rigor – How I shipped more in two weeks than in a year

How a CTO discovered that AI velocity requires more engineering rigor, not less.

I shipped more in one month than all of last year. Here’s what I learned.

I still love to code. There’s something deeply satisfying about solving a puzzle, about seeing tests go green, about that moment when a complex system clicks into place.

So when I tell you that I barely wrote any code during Christmas and yet shipped more working software than I have in years, I need you to understand: this isn’t about giving up what I love. It’s about discovering something even better.

What two weeks looked like

Over the holiday break, I built a pretty complex production system: a serverless application on AWS with Lambda functions, DynamoDB single table design, Step Functions orchestration, and a Telegram bot user interface. The numbers surprised even me:

I didn’t write this code. But I engineered every bit of it.

The system was built using Claude Code with a Pro 20x subscription. The interesting story isn’t “AI wrote all the code.” It’s what it takes to make AI-assisted development actually work.

The Mindset shift

Here’s what changed in my head:

• Before: “AI can’t do X yet”
• After: “I haven’t instructed AI to instruct itself on how to do X”

This sounds subtle, but it’s everything. I worked together with Claude Code to set up the development tooling as well as various scripts to manage Github issues and pull requests. Whenever I was doing something by hand, I tried to stop and figure out how to enable Claude Code to do it for me.

As one extreme example, when I needed an event-driven system with Step Functions, SQS queues, and idempotency handling, I didn’t write a specification first. I asked Claude Code to write throwaway code that nailed down the data models and logic first.

The code became the spec. The spec became the code.

AI velocity requires more rigor, not less

Moving faster with AI required me to invest more in engineering discipline. AI-assisted velocity without rigor just produces technical debt faster.

This project implements layered quality gates: formatters and linters catching style and common bugs instantly; unit and integration tests proving correctness; static analysis measuring complexity and coupling; architectural tests enforcing design constraints; and system integration tests verifying the deployed system end-to-end. All checks feed into a CI pipeline that spins up ephemeral environments for every PR.

The key insight: all of this tooling is available to the AI directly. The agent runs linters, tests, and analysis, then iterates on its own output. The tighter the automated feedback loop, the more autonomously it works, and the higher the quality.

More automation enables more speed. Without these gates, AI velocity becomes technical debt. With them, it becomes sustainable acceleration. My test code is 2.5x the source code. I believe this ratio is needed to move fast sustainably.

What “senior” means now

Some developers worry: if AI writes the code, what’s left for us? Everything that matters.

I still used all my engineering instincts: designing architectures, thinking through edge cases, knowing when something smells wrong. The difference? I spent my time on the interesting problems. Not syntax. Not boilerplate. Instead: What should this system do? How should components interact? Is this the right abstraction?

A senior developer in the AI era knows what to build (and what not to build), designs systems AI can implement reliably, and reviews output with judgment from experience. The expression changes. The essence doesn’t.

What this means for Alma

Industry research tells a consistent story: a widening gap is forming between organizations that embed AI into how they work and those that treat it as a peripheral tool. The DORA 2025 report put it plainly: successful AI adoption is a systems problem, not a tools problem.

This matches what I’ve seen. The bottleneck is never the tool. It’s the engineering practices, quality infrastructure, and organizational willingness to rethink how software gets built.

At Alma, we’re treating this as a strategic capability. We run bootcamps, share learnings across teams, and build communities around AI-assisted development. Most importantly, we’re investing in the engineering rigor that makes AI velocity sustainable.

The developers who thrive won’t resist change, and they won’t blindly accept AI output. They’ll bring engineering judgment, taste, and domain expertise—and multiply it.

I spent Christmas coding more than I have in years. Just not the way I used to.

The love of code isn’t about typing characters. It’s about building things that work. AI doesn’t take that away. It gives you more of it.

The author is Antti Koivisto, Chief Technology Officer of Alma Media, focusing on technology strategy, AI adoption, and engineering culture.

Share article