Competence by Proxy

Here's a question that keeps showing up in our survey data, usually buried in the optional "anything else?" section at the end of the AI Fatigue Quiz — the place where people tell you what they actually think:

"How much of what I can do now is me, and how much is the AI?"

It's not rhetorical. Engineers are genuinely unsure. And it matters more than we think.

The Competence by Proxy Problem

There's a specific cognitive phenomenon that happens when you use AI tools heavily as an engineer. It goes like this:

You encounter a problem you don't fully understand. You describe it to an AI. The AI produces a solution. You review it, understand it at a surface level, and ship it. The feature works.

Now: are you more competent than you were before?

On one level, yes — the feature exists, and you oversaw it. But on another level, something more specific happened: the AI was competent, and you were the interface between the AI's competence and the production system. You managed the AI. You didn't become more capable yourself.

This is what we mean by "competence by proxy." Your output is more capable than your unaugmented abilities would allow. But the capability lives in the tool, not in you.

Most engineers working heavily with AI are living in Scenario B most of the time, and occasionally sliding into Scenario C. Scenario A — where the AI genuinely teaches you something you couldn't have figured out alone — is the exception, not the rule. And that's not a moral failing. It's just the math of how these tools work.

Why This Is Harder to See Than It Should Be

Here's the uncomfortable part: the output looks identical from the outside. Scenario A (you learned it) and Scenario C (you didn't) both produce working features. The PR is merged. The ticket is closed. Nobody can tell from the outside which version of understanding happened inside your head.

This is why the "just use AI mindfully" advice fails. It assumes you can tell the difference between Scenario A and Scenario C in real time. You often can't. The confidence that comes from shipping working code is the same in both cases. The feeling of productivity is the same. The only way to know the difference is to test it — to try to do it without AI and see what happens.

Most engineers don't do that test, because the test is slow and uncomfortable and the output is uncertain. So they go months without knowing whether they're in Scenario A or Scenario C. And the gap compounds.

Not "would struggle with." Actually couldn't. That's the boundary of your competence without a proxy. And that boundary is probably narrower than you think.

Why This Matters for the Skills Debate

There's a lot of noise right now about whether AI is making engineers "lazy" or "dependent." Most of that framing misses the point.

The issue isn't dependency — it's that the dependency is invisible. If you knew you were operating at Scenario C level on a specific skill, you could make a conscious choice: do the slow work to grow into Scenario A, or accept the boundary and structure your work around it.

Most engineers aren't making that choice. They're just operating at Scenario C, feeling vaguely like something is off, and attributing the feeling to tiredness or burnout or imposter syndrome — when it's actually a calibration problem. The output is good. The growth isn't happening. And the gap is invisible unless you test for it.

This Week's Reflection

Before you close this email, take sixty seconds. Open a text file and answer this:

The engineers who navigate this well aren't the ones who avoid AI. They're the ones who are honest with themselves about which scenario they're in — and who deliberately seek out the Scenario A moments, because those are where the actual growth happens.

The rest is throughput. And throughput isn't nothing — but it isn't growth either.

The capability that lives in you is the only capability that can't be taken away.
— The Clearing