Revisiting Old Code: Lessons in Growth, Enterprise vs. Startup Mindsets, and AI-Driven Infrastructure Evolution

Every developer knows the feeling. You open a project you built a few years back, and the first thing that hits you is disgust. Pure, visceral disgust with yourself. As a freelancer, I get this constantly, but I imagine lifers at companies feel it too. If you've never experienced it, you're not learning. You're not growing. The community around you, the tools, the patterns, the workflows, all of it keeps moving. Sometimes something disruptive comes along and forces you to rethink everything. To stay the same, you actually have to get better, because everyone else is optimizing.

Yesterday I revisited a startup project from years ago, and it wrecked me. Multiple factors made it painful. Years had passed and standards had shifted. The founder's budget was tight, so corners got cut. And I was in the middle of transitioning to enterprise work at the time, which meant I was applying all these rigorous practices that had no business being in a startup codebase.

Enterprise Brain Is Real

When you move from startups to enterprise, you notice how much security, high availability, and compliance dominate everything. Enterprise breaches can cost millions. Startups don't carry that same risk profile. But that knowledge creates this insecurity where you start thinking startup practices are "wrong." You get almost religious about enterprise methods. Strict IAM policies, modular Terraform, the works. Anything less feels shameful.

The problem is startups need the opposite. They need speed. Quick user acquisition, market validation, getting something in front of people before the money runs out. Enterprise-grade infrastructure doesn't help you find product-market fit.

In this project, I overengineered the security and the Terraform code, and it slowed everything down. What the startup actually needed was the basics: MFA, strong passwords, reasonable defaults. Compliance can wait until you've proven the product works. Infrastructure as code traditionally locks in your gains, enables rollbacks, lets you duplicate environments. All good things. But overengineering it in a startup context kills the very agility that keeps a startup alive.

A mono-repo with infrastructure code sitting alongside app code strikes the right balance for a startup. You get observability and speed without the rigid separation that enterprises need for compliance. That's a hard thing to internalize when your brain has been rewired by enterprise work.

AI Changed the Refactoring Math

Generative AI tools have completely changed this equation. They generate clean code from clear requirements, and they do it fast. There's no excuse for poor quality anymore. I used to leave TODO comments everywhere, backlogs of refactoring tasks I'd get to "eventually." Now agents suggest code blocks instantly, and the hallucination problem has gotten way better than people think. Refactoring and rewriting went from "someday" to "right now," which honestly compounds the disgust when you look at old code. You know how easy it would be to fix.

For IaC specifically, AI enables a code-first deployment approach. You can generate Terraform from requirements faster than clicking through a cloud console. For startups, that means lightweight IaC in a mono-repo, letting developers manage their own workloads without enterprise gatekeeping.

The DevOps Insecurity Loop

Here's something nobody talks about. As a cloud architect or DevOps engineer, you review way more code than you write. That creates its own insecurity about your coding ability. So when you do write code, you overengineer it. Your Terraform becomes a showcase of everything you know instead of what the project actually needs. But IaC isn't about showing off. It's about guardrails.

The real DevOps value is prioritizing bottlenecks using cloud metrics and guiding developers toward high-impact optimizations, like writing efficient database queries instead of throwing more compute at a slow endpoint. In startups, keep the infrastructure simple. Maintain that agility. Scale up to enterprise rigor when the business demands it, not before.