In the 1980s, my mother and I represented two different worlds of software development, divided not just by the tasks we performed, but by the very philosophy of how code should come into being. She was a database developer for a corporate giant, practicing a meticulous craft known as Top-Down design. She and her team would spend weeks, sometimes months, living in the realm of diagrams, flowcharts, and structured English. Only when the design was considered complete, perfect, and immutable would they hand it off. It was then passed down the food chain to the "coders"—a term uttered with a subtle, institutional disdain—whose job was simply to transcribe that design into a working program. My job, as a junior firmware engineer, was the polar opposite. I lived in the trenches of C and Assembler, holding a general design in my head while my fingers did the talking. We built from the bottom up, learning what the system needed to be by the act of building it and debugging the inevitable failures.
For decades, the bottom-up, iterative approach won. It became the dogma of agile development, test-driven design, and the very culture of modern programming. We believed that code was truth, and that planning was merely a precursor to the real work of writing and refactoring. But with the recent explosion of sophisticated AI agents, I have watched my own workflow evolve into something unexpectedly familiar. I no longer write code. Instead, I find myself doing something I once associated with my mother’s generation: I design.
My current process is a strange echo of that 1980s corporate structure. I begin in "planning" mode with an AI, hashing out requirements, sketching architectures, and debating edge cases in plain English. I am creating the blueprint. Only when I am satisfied with the plan—when the logic feels sound and the structure is coherent—do I give the AI the green light to go away and do the hard work of translation. It becomes the "coder," turning my design into functional syntax. And then, just like in the old days, the work comes back for review. The code is never perfect. There are bugs, subtle misunderstandings from the planning phase, or logical leaps that looked good on paper but failed in practice. We iterate. We go back to the drawing board.
In this model, I have become my mother. My value is no longer in my dexterity with a specific syntax or my ability to debug a stack overflow at 2 a.m. (though that knowledge certainly helps). My value is now in my ability to design a solution. The AI handles the transcription, the translation of logic into machine language—the very job of the "coders" from a bygone era. The hierarchy has returned, but the roles have shifted. I am now the senior architect; the AI is the junior programmer executing the spec.
We have not just evolved; we have come full circle. The rise of the coder as the central figure of development, which dominated the 90s and 2000s, appears to have been a historical anomaly—a period where the complexity of the machine required humans to speak its language directly. Now that the machine can speak ours, we are free to ascend back to the realm of pure logic and design. The tools have changed—diagrams have become prompts, and flowcharts have become conversation—but the fundamental separation of concerns is back. We are no longer craftspeople shaping every line of code; we are architects describing the building, leaving the bricklaying to the tireless, literal-minded assistants we have built.
These are my thoughts, but written with the help of an AI Agent.
No comments:
Post a Comment