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 — and eventually 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?