Software Engineering Is Dead, or Is It?
The boring stuff was load-bearing all along.
Everyone said agentic coding would kill software engineering discipline. Turns out it killed the wrong disciplines.
Hey, I’m Lakshmi — I help developers build, deploy, and distribute their SaaS without hiring a team. I also run Stacksweller and Supabyoi.
New here? Start with Why Your AI Wakes Up Every Morning With No Memory or Clean Code Is Dead.
Clean code? Dead. Nobody’s hand-crafting variable names when Claude generates 500 lines in 30 seconds. But TDD, specs-driven development, domain-driven design — the stuff we used to skip because it felt like ceremony? That’s the load-bearing wall now. Tear it out and the whole thing collapses.
TDD: The Cache That Wasn’t
I had Claude Code build me a Redis caching module. Proper TTLs. Cache invalidation on writes. Unit tests passing. Beautiful, elegant, chef’s-kiss code.
One problem. The actual query functions never called the caching layer.
Hundreds of requests later, I checked Redis. Empty. A pristine, untouched Redis instance, sitting there like a museum exhibit. I’ve written about these failure patterns before — this one hurt the most.
Integration tests would have caught it. But only if I’d written them first. That’s the part everyone skips — writing the verification before the implementation. TDD forces you to define “done” before the agent starts building. Without it, you get beautiful isolated components that nobody wired together.
This isn’t hypothetical. An r/programming thread (894 upvotes) nailed it: “We’re getting correct code, but not right code.” One reviewer found AI-generated Java using the default ForkJoinPool for I/O-bound tasks. Compiles fine. Passes unit tests. Catastrophic under load.
My favorite was the “chief architect” who generated “full coverage” unit tests with Copilot. Duplicate asserts. Unused service constructions. Tests that passed but tested nothing. A green CI pipeline that was essentially a participation trophy.
TDD isn’t ceremony anymore. It’s the spec your agent actually follows.
Specs-Driven Development: The Authentication Amnesia
I spent two weeks pair-programming authentication with Claude Code. We tracked race conditions together. Debated RS256 vs HS256. Built a shared understanding of every edge case.
Then compaction hit.
“Where did we leave off?”
“I don’t have information about previous sessions.”
Two weeks of context. Gone. My TODO.md became a graveyard of cryptic notes that made sense to exactly nobody, including me three days later. I wrote the full horror story here.
So I started using a git-backed issue tracker with dependency graphs that persists across agent sessions. Sprints and epics stopped being PM ceremony and became the agent’s memory. The control plane for multi-session work.
The pattern scales beyond my personal disasters. An r/programming post titled “The era of AI slop cleanup has begun” (4,200 upvotes) described a freelancer who keeps getting hired to fix AI-generated codebases. “It mostly works, but does so terribly.” The missing ingredient every single time: no structured planning, no phased delivery. Just vibes and a prompt.
Fred Brooks said it decades ago, and r/ExperiencedDevs rediscovered it (1,400 upvotes): “Once requirements are fully expressed, their information content is fixed. You can change surface syntax, but you can’t compress semantics.”
You can’t skip the thinking. You can only skip writing it down — and then you pay for it later when your agent wakes up with amnesia.
DDD: The Firewall Agents Can’t Generate
Here’s a Reddit thread that lives in my head rent-free. Someone described the “Phantom Author” problem — only domain experts catch the subtle flaws agents produce. The code compiles. The tests pass. The logic is plausible. But it’s wrong in ways only someone who understands the domain would notice.
The punchline: “Ironically the only people who should be using AI are people who are already experts.”
Bounded contexts — the core DDD concept — are the firewall. They tell the agent where one domain ends and another begins. Without that modeling, agents connect everything to everything. Your billing module knows about your notification preferences. Your auth layer has opinions about your recommendation engine.
Agents can’t generate domain boundaries because domain boundaries come from understanding the business, not the code. That’s your job. The agent’s job is everything inside the boundary.
The Punchline
The disciplines that survived aren’t the ones that made code pretty. They’re the ones that tame complexity.
TDD tells the agent what “done” means. Specs give it memory across sessions. DDD gives it boundaries it can’t infer on its own.
We didn’t need less engineering discipline. We needed different engineering discipline. The ceremony is dead. The structure is mandatory.