
Designing My Role in an AI-First World: What Will I Choose to Be Responsible For?
Six months ago, I watched an AI coding assistant scaffold an entire authentication flow for a portfolio project in under a minute — routes, middleware, token handling, error states. Two years ago, that would have taken me an evening. The uncomfortable question that followed wasn't "is this good code?" It was "what exactly am I for, if this is how fast the easy 80% now goes?" That question is the one this essay tries to answer honestly, using software development — my own field — as the scenario
Where AI already sits in the workflow
The shift isn't hypothetical anymore. Nearly nine in ten engineering teams now report using AI somewhere in their workflow, up sharply from roughly six in ten just a year earlier. On a single team's codebase, AI now generates around a third of all new code, alongside code written from scratch and code reused from elsewhere — a three-way split that would have sounded absurd five years ago. Deployment pace has moved with it: a large majority of teams using AI in their software lifecycle now ship multiple times a day.
For a student like me, entering the field right as this shift completes, the "easy parts" the scholarship prompt refers to are concrete: boilerplate, first-draft functions, test scaffolding, documentation, syntax lookup, even architectural sketches when I describe intent in plain language. None of that is speculative — it's what I already lean on when I'm building.
What still needs a human
Here's the part that surprised me most: developers who use AI daily are, at the same time, the most skeptical of it. Only a small fraction of surveyed developers say they highly trust AI's output, and nearly half report some level of active distrust — a number that's grown, not shrunk, as adoption grew. Barely one in twenty think AI handles genuinely complex tasks well. That gap between adoption and trust is the clearest evidence I've seen that fluency with AI output isn't the same as competence — and competence is still squarely a human job.
In practice, this means three things stay mine to do, not the AI's: judging whether generated code is correct for this specific system (not just plausible-looking), catching the failure modes AI tools are bad at — subtle state bugs, security assumptions, edge cases outside the training distribution — and making the actual design tradeoffs: which parts of a system should be simple versus flexible, what technical debt is acceptable now, what will break under real user load. AI can generate five ways to solve a problem in seconds. It has no stake in which one is right for this product, these users, this team's constraints. That judgment call is still entirely human, and I don't see that changing — it requires context AI doesn't have access to and consequences AI doesn't bear.
Who's responsible when it breaks
This is the question I used to dodge, and it's the one the prompt forces me to answer directly: if AI-generated code ships a bug, or a security hole, or a bad architectural decision — that responsibility doesn't transfer to the tool. It stays with whoever reviewed and approved the change. In a professional setting, that's the developer who committed it and the reviewer who signed off — not the model, and not "the AI" as an abstract entity. I've already started treating my own portfolio and side projects this way: nothing generated goes in without me being able to explain, line by line, why it's there and what it does. If I can't explain it, I don't understand it well enough to be accountable for it, and I don't ship it. That's a discipline, not a rule someone hands you — and it's the one I think matters most going into a first job, where the stakes of "I didn't fully understand what I merged" are much higher than in a class project.
How the decision actually gets made, in practice
In the teams I've read about and the internships I've watched friends go through, the pattern is consistent: AI proposes, a human disposes. Code review hasn't disappeared — if anything, it's become more important, because now someone has to catch not just human mistakes but AI's confident-sounding wrong answers too. The decision of what ships is still made by a person reading the diff, running it against real constraints, and putting their name on the approval. That's not a temporary phase before AI takes over review as well — it's a structural feature of how software actually needs to work, because someone has to be answerable when a system in production fails, and "the model suggested it" has never been an acceptable postmortem line.
My personal strategy — and where it could fail
Going forward, I'm choosing to be responsible for three things AI can't currently substitute for. First, systems-level thinking: understanding how pieces of a codebase interact, not just how to generate any one piece — this is why I build full projects end-to-end rather than isolated snippets, even when AI could hand me the isolated snippet faster. Second, the review discipline I described above: treating "I can explain this" as a hard gate before anything ships, especially in work I put my name on publicly. Third, staying deliberately hands-on with the parts of development that are hardest to verify by reading — debugging live systems, reasoning about performance under real load — because those are exactly the areas where trusting AI's confident output uncritically is most dangerous.
Where this could fail: leaning this heavily on "I'll always personally verify everything" doesn't scale forever. As AI tools get better at complex reasoning — and the data suggests they are, even if slowly — the honest risk is that verification itself becomes the bottleneck, and I get pressured to approve faster than I can genuinely understand. I don't have a clean answer to that yet. My current plan is to keep my personal verification standard non-negotiable on anything safety- or security-relevant, even if it costs me speed, and to accept that speed elsewhere. That's a bet, not a certainty, and it may need to change as the tools change.
Conclusion
AI hasn't removed my role from software development — it's compressed the part of the role that was always the least interesting anyway: typing out the obvious. What's left is the part that was always harder to automate and always mattered more: judgment, accountability, and the willingness to put your name behind something you actually understand. That's the role I'm choosing. It's not the safest bet available, but it's the honest one.
Enjoyed reading this content? Let the author know!
Your likes, comments, shares, and saves help creators reach more builders.
Loading recommendations
Loading article