I was promised software engineering would be solved

I was promised that OOP would solve all the software engineering problems if only I modeled the world in objects and relations between them.

I tried really hard. But mixing state with behavior and abstracting that with interfaces often ended up as a complete fragile mess.

The problem was I didn’t use design patterns, they said. I tried that, and I also bought into DDD because there was a better way to model business domains. If only I could describe business in code, adjusting to new requirements would become an easy job. Especially if I practiced TDD or BDD and could quickly localize and test the change.

Guess what? Formulating requirements was hard. Some business rules were hard to model into code, and you should have built that feature yesterday—no time for tests.

We also had been splitting all that into microservices isolated by domain contexts for simplicity. But instead of simplicity, we got distributed complexity.

I played with Haskell. And then Scala! Functional programming. Everything is typed and defined like mathematical equations. I felt it was it. It is easy to reason about, and if it compiles, it works.

But the problem became the reasoner itself. I found functional programming the closest to human language, but the amount of work and learning curve it requires to pick up as a skill was tremendous to make it mainstream.

And then came AI coding agents; they promised me that all the problems I just described were not relevant at all. I could generate thousands of lines of code without reviewing or use other agents for review. And I should not worry because the next versions of the models would fix all the current issues.

And here I am, still in love with software engineering, and still naive enough to believe them. Going all-in on coding with AI, expecting it will help me write quality production code faster and cheaper, and spending countless hours on code review, refactoring, and testing all that generated code.