I'm a self-taught developer with a civil engineering background and a little over three years of professional software development experience. Until recently, I mainly used language models as a faster alternative to searching for documentation or examples. After moving into a more senior role at a software consultancy, I started using agentic workflows heavily because projects have tight deadlines, clients prioritize delivery speed, and we frequently switch between codebases.
I helped define the agent rules for my team, and roughly 95% of the code in my current project is now AI-generated. The generated code follows strict conventions for file structure, naming, testing, API documentation, and more. Producing the same amount of code manually would take me several times longer, especially when unfamiliar framework syntax is involved.
The problem is that I'm starting to feel less sharp. Code reviews are harder, I don't understand every part of the codebase as deeply as I used to, and much of my time is spent supervising agents and reviewing AI-generated changes, often in broad chunks rather than line by line. I'm worried that I'm becoming a weaker developer instead of continuing to grow.
Outside work, I've tried reading technical books and learning tools such as Go and LangChain, but I've been jumping between topics and feeling burned out. How do you stay technically sharp and continue improving when AI is responsible for most of your implementation work? Is heavy AI-assisted development becoming the normal direction of the industry, and how can you tell whether you're using it productively or relying on it too much?
4 Answers
Try treating the agent as an assistant rather than the owner of the solution. Before asking it to implement something, write down the design, constraints, and likely edge cases yourself. Afterward, inspect the important paths, run targeted experiments, and ask the agent to explain alternatives rather than accepting the first output. You don’t need to hand-write every line, but you should remain capable of tracing the system and defending the decisions in a review.
The important distinction isn’t whether AI wrote the code. It’s whether you understand and can evaluate the result. Read the documentation for the frameworks and APIs you use, investigate bugs yourself, and review generated changes deeply enough to explain their design and failure modes. AI-generated code still needs an engineer who can reason about correctness, security, performance, and maintainability.
Use AI for leverage, but deliberately keep some areas of your development practice manual. A small side project, command-line tool, or game built without AI can keep your implementation instincts active without adding pressure from deadlines. It doesn’t need to be useful or polished; the point is to practice designing, debugging, and finishing something yourself.
Some skills will naturally fade when they stop being necessary, and that isn’t automatically a problem. Developers have always worked through layers of abstraction. The valuable skills are shifting toward defining problems, making architectural decisions, understanding systems, and delivering reliable products. However, abandoning fundamentals entirely is risky because you need those fundamentals to recognize when generated code is wrong.
That’s the part I’m unsure about. A developer with several more years of experience should still have deeper judgment than someone just starting out. If AI does all the implementation, we need to make sure people are still building that judgment instead of becoming passive users.
That’s what I’ve started doing too. My job can involve letting agents produce most of the code, so I make small games and experiments outside work where I write everything myself.