The Last Generation of Developers Who Learned to Code Manually

A developer reflects on how AI is reshaping software engineering, comparing it to past shifts like higher-level languages and Stack Overflow. The author argues that AI is the next abstraction layer, moving the bottleneck from writing code to understanding systems and trade-offs. The post draws parallels to console generations, where developers eventually learn to maximize new tools.

There was a time when software engineers had to understand the machine almost as much as the software itself. Not metaphorically. Literally. Game developers working on older consoles didn’t just write games, they engineered around physical limitations. Cartridges weren’t just storage devices. Developers learned how to manipulate the hardware itself to squeeze out more performance, more memory, more possibilities. Every byte mattered. And that got me thinking about AI. Not in the “AI is replacing developers tomorrow” kind of way. More in the: “What actually happens to software engineering when the hardest part is no longer writing the code itself?” kind of way. Because if you zoom out far enough, software engineering almost feels like a long history of abstraction. Each generation moves one layer further away from the metal. Early programmers needed to think about hardware constantly. Memory constraints. CPU cycles. Storage limitations. Manual optimization. Then came higher-level programming languages. Suddenly we weren’t flipping bits or writing assembly for everything anymore. Languages started handling more complexity for us. Eventually memory management became less painful too. Manual garbage collection gave way to runtimes and managed environments. Frameworks appeared. Libraries exploded. Open source communities grew. And slowly, software engineering started becoming less about building everything yourself, and more about knowing how to assemble systems effectively. Then came another massive shift: the internet. More specifically, searchable knowledge. Sites like Stack Overflow completely changed how developers worked. Before that, a lot of programming knowledge lived in books, documentation, university courses, or the minds of senior engineers guarding ancient deployment rituals like dragons protecting caves of gold. Then suddenly: Developers joked about it constantly. “99% of programming is just Googling.” “Stack Overflow is my senior developer.” At the time, some people criticized this shift. “You don’t really understand the code.” “You’re relying too much on external knowledge.” But something interesting happened. Developers didn’t become less productive, they became dramatically more productive. The value wasn’t memorizing syntax anymore. It became understanding systems, architecture, trade-offs, debugging, and knowing how pieces fit together. And now AI feels like the next evolution of that same pattern. Today, AI can: Sometimes frighteningly well. The weird part is that this changes the development process itself. For years, writing code was the bottleneck. Now the bottleneck is slowly becoming: Maybe the future software engineer spends less time manually writing every line and more time acting like: Not replacing engineering knowledge, but changing where that knowledge gets applied. What’s fascinating is how familiar this all sounds. People once mocked developers for relying on Stack Overflow. Now people mock developers for relying on AI. But maybe we’re watching the same cycle repeat itself. Every major leap in software engineering seems to create fear that “real engineering” is disappearing. Higher-level languages. Frameworks. Libraries. Search engines. Open source. Cloud infrastructure. Each abstraction reduced friction. Each abstraction also changed what skills mattered most And every time, developers adapted. One thing I keep thinking about is console generations in gaming. If you compare early games released on a console to games released near the end of that same console’s life cycle, the difference is insane. Developers eventually learn: By the end of the generation, you get masterpieces that seemed impossible when the console first launched. That honestly feels a lot like where we are with AI right now. We’re still shipping the equivalent of launch titles. Some AI-assisted software today feels messy. Over-engineered. Poorly understood. Built too fast. Held together with hope, dreams, and motivational quotes. But that might simply be the awkward early phase of learning a new tool. Over time, developers will probably learn: And eventually, teams that truly understand these tools may build things that feel impossible by today’s standards. I don’t think software engineers disappear. At least not in the way some people predict, but I do think the role evolves. The same way engineers once moved: …we may now be moving toward intent-driven development. Where the real skill isn’t: “Can you write every line manually?” But rather: “Can you design, guide, validate, and refine complex systems effectively?” Because AI can generate code. But understanding: trade-offs scalability maintainability security user experience business logic architecture That still matters, and maybe now more than ever. I don’t think we fully understand yet how AI will reshape software engineering. Honestly, I think we’re still in the experimental phase where everyone is simultaneously excited, confused, skeptical, and slightly terrified. But looking back at the history of software development, one thing seems consistent: Every major abstraction changed the way engineers worked. And every time, the developers who learned how to properly use the new tools ended up building incredible things. Maybe AI is just the next chapter in that story, or maybe it’s the biggest shift yet. Either way, I think we’re witnessing a fascinating moment in software engineering history. And I’m very curious to see what developers become on the other side of it. What do you think? Are we moving toward a future where developers become architects of intent? Or do you think AI-assisted development is being massively overhyped?