AI-Native Engineering Story

Daniel Stolf — Wed, 27 May 2026 15:00:00 +0000

In 2020, during the pandemic lockdown, I built a working Kubernetes CSI Driver prototype in a hackathon.

It was good enough to win. But turning it into a production-ready integration took months. Eventually it required a team of 3 additional engineers to get there.

Same person. Same domain. Same company. Months, plus a team.

Fast forward five years.

I built a production Kubernetes Operator (a more complex project) in 2 weeks. Solo. No team allocation. No formal project approval. Just me and a workflow I’d developed almost by accident.

Same person. Same domain. Same company. 2 weeks, alone.

The only thing that changed was how I worked with AI.

Here’s what that workflow actually looked like, before it even had a name:

Step 1 - Spec-driven architecture

I didn’t start by writing code. I used high-reasoning models (ChatGPT, DeepSeek) to think through the design, discussing trade-offs, challenging assumptions, generating a structured Markdown spec with architecture decisions and code scaffolding. The model was my technical co-founder.

Step 2 - Grounding the model

LLMs hallucinate on fast-moving APIs. Before writing any implementation code, I researched and injected the relevant documentation (Kubernetes controller-runtime specs, CRD patterns, Delphix API definitions) directly into context. The model then worked from accurate, current sources. I was doing RAG manually before RAG was a term most people used casually.

Step 3 - Agentic execution

With the spec as a foundation, I used GitHub Copilot to drive implementation, iterating on specific functions, sharing code segments with targeted prompts, reviewing and correcting outputs. Claude Code came later and accelerated the final stretch further.

The result wasn’t just a faster build.

It broke a structural go-to-market deadlock. Without a working solution, customers wouldn’t commit. Without customer demand, engineering wouldn’t prioritize it. By shipping a working MVP first (alone, in two weeks) I generated real demand from a working product.

That converted a churn risk into a US$30M enterprise deal.

The 2020 hackathon wasn’t a failure. The CSI Driver became the technical foundation the Operator was built on. But the contrast matters:

The same engineer. The same problem space. A team and months, versus solo and two weeks.

What changed wasn’t the engineer. It was the workflow.

The practices I stumbled into out of necessity (spec-driven development, context grounding, agentic coding loops) are now what enterprises are actively trying to learn and implement at scale.

The gap between “we’re experimenting with AI” and “we’re shipping with AI” is mostly a workflow problem. It’s not about the model. It’s about how you work with it

What’s the biggest shift you’ve noticed in how your team builds since AI tools became mainstream?

DEV Community: Daniel Stolf

AI-Native Engineering Story