I'm six months into my first junior software engineering job while studying computer and software engineering at university. I've already worked on complex bug fixes, performance improvements, and end-to-end features, but I've relied heavily on AI agents to get many of those tasks done. I usually understand most of the resulting code, yet I'm worried I couldn't independently solve a problem of similar complexity without the agent's help.
At a fast-moving startup, stopping AI use completely would probably reduce my productivity, so I'm looking for a gradual approach. How can I keep using AI responsibly while building the ability to reason through and implement more complex work on my own?
5 Answers
Be deliberate about where the agent is allowed to lead. Use it freely for boilerplate and patterns you already know, but turn it off for the specific concept or skill you’re trying to develop. Before accepting a change, predict what the agent will do and then compare your prediction with the result. The difference shows you exactly what you need to learn.
When it fixes a bug, explain the root cause before moving on. Also try to break the solution by testing edge cases the agent may have missed. A useful exercise is choosing one small project each month and building it end to end without AI. It will feel slower, but that discomfort is useful practice.
Try the “see one, do one, teach one” approach. Let the agent show you how to solve something, then reproduce the solution yourself later without looking. Finally, explain the approach back in your own words. The important part is not just understanding the solution while it’s in front of you, but building the memory and confidence to carry it out independently.
You don’t need to reject AI entirely. The valuable skill is understanding the underlying concepts, reading documentation, reviewing code, and recognizing when an answer is incorrect. Syntax is increasingly easy to generate, but architecture, debugging judgment, requirements, and trade-offs still require strong fundamentals. Keep using the tool, but make sure you can explain and evaluate everything it produces.
Don’t treat the agent’s output as a black box. Read the diff carefully, ask why it chose that approach, and consider at least one alternative implementation. If anything is unclear, keep asking questions until you understand every important part, including the trade-offs and assumptions. Even experienced developers do this when working with unfamiliar languages or libraries.
That makes sense. Comparing the chosen solution with alternatives seems like where much of the real learning happens, instead of simply accepting whatever works.
Occasionally build something substantial with no assistance at all. A project such as a small 3D software renderer forces you to work through algorithms, data structures, debugging, and design decisions yourself. You don’t need to do this for every work task, but challenging independent projects can reveal which fundamentals need more practice.
I really like that framing. Having the agent show me once isn’t very different from a person walking me through it—the part I’ve been skipping is actually doing the next rep from memory.