Agentic Skill Decay

Justy Okay, so this is Addy Osmani basically naming something everyone's running into right now but nobody wants to say out loud: agents finish your work so fast that you never learn how to do it.

Cody Right.

Justy And it's not a hot take, it's not cynicism about AI—it's a real apprenticeship problem. You need reps to build expertise. You need to fail, debug, read other people's code, sit with a system until it pushes back and you understand why. Agents let you skip all of that. Task done, ship it, move on.

Cody I mean, the framing's fair, but I want to see the evidence before I buy the severity.

Justy He cites an Anthropic study from 2026. Junior engineers learning Python's Trio library. AI group scored fifty percent on a follow-up quiz. Hand-coding group scored sixty-seven.

Cody Hm.

Justy But here's the thing: within the AI group, the people who asked conceptual questions and requested explanations instead of just using it as a code vending machine—those people scored much higher. So it's not that agents are broken. It's that most people aren't using them right.

Cody Okay, that changes the frame. So the gap isn't 'agents are bad at teaching,' it's 'most people are bad at using agents for teaching.'

Justy Exactly. And if you just ask for code, you don't learn. If you ask why, inspect the diff, predict what might fail, you stay in the loop and your mental model moves with the agent.

Cody But the delta is meaningful: seventeen percent. And for junior engineers especially, that's three years into their career and suddenly code arrives faster than their ability to judge it. You're shipping plausible solutions you don't actually understand.

Justy So the real risk isn't that you can't ship. It's that you can't verify, can't debug when it's weird, can't make taste-based decisions about trade-offs. You're a very efficient code vending machine operator, but not an engineer.

Cody And that's a hiring problem. Because right now you've got this massive pressure to ship fast, and agents absolutely enable that. But teams are also going to start noticing that they've hired people who can prompt really well and can't actually reason about what they built.

Justy Already happening, I think. And Addy's point is it's not the agent's fault—it's deliberate. You have to choose to stay in the loop. Form a hypothesis before you prompt. Ask why. Read the diffs. Predict what might fail. Occasionally work through a small problem by hand.

Cody Mm-hm.

Justy He talks about his own practice with performance optimization—thousands of hours spent learning Chrome DevTools, memory constraints, hardware limits. That expertise is valuable because he's internalized the failure modes. An agent can spit out optimization code, but if you've never lived with a bad optimization, you don't know what to verify.

Cody That's the real load-bearing thing here, right? Verification. Because once you're shipping agent code at scale—especially to production—you need judgment about what to check, what could go sideways, what the agent might have missed. That comes from reps.

Justy Which brings him to the infrastructure piece—if an agent's got Postgres access, how do you even know what it did? Identity-based access, scoped to the task, expires when it's done, audit trail ties every query to a specific agent and the human behind it.

Cody Okay, that's smart. Because the problem isn't just 'did the agent make a mistake'—it's 'what did the agent actually do, and can I trace it back to understand why.'

Justy And it's such a boring fix. It's not about smarter prompts or better models. It's just... do identity right. Which is exactly the pattern we keep seeing.

Cody The unglamorous control layer is the whole game.

Justy Every time. But here's the thing that doesn't have a clean answer: Addy says he uses agents aggressively. Multiple sessions running. He's not romanticizing typing every line. He's just saying you have to be intentional about staying in the loop, and most people aren't.

Cody Right. And the pressure to ship fast isn't going away. So you've got this tension between 'I need to learn' and 'I need to deliver.' And most organizations are going to choose delivery.

Justy Which means the skill gap widens. And the people who stay in the loop—who ask why, who read the diffs, who form hypotheses—those people become more valuable, not less.

Cody Assuming organizations recognize that. Which… I'm not sure they will, at first.

Justy No, they'll notice when they can't hire people who can actually reason about code. But by then, a whole cohort of junior engineers will have optimized for speed instead of understanding. That's the real cost.

Cody So the fix is education, basically. Addy's saying junior engineers have to be proactive about their learning journey. Ask for explanations, not just code. Work through problems by hand sometimes. Stay in the loop.

Justy Exactly. And it's not a given. Most people don't think to ask. They don't know it's an option. Or they're under velocity pressure and can't afford to slow down. So it has to be deliberate.

Cody Yeah.

Justy And honestly, I think this is going to be one of the defining splits in the next few years. People who treat agents as partners in learning versus people who treat them as code machines. And the gap's going to show.

Cody It already is, according to that Anthropic data.

Justy Right. Seventeen percent on a quiz. Multiply that across a career and it's a different engineer.