Everyone is asking the wrong question. “How do we adopt AI agents?” “Which tool?” “What’s the right policy?” Wrong questions. The right question is: how does your team turn what one person learned on Tuesday into something everybody on the team uses by Friday?
The Real Question Isn’t About AI
The models are getting better every two months whether you like it or not. The tooling shifts under your feet. Best practices that worked in March are mediocre in June. If your organization takes six months to absorb a new technique, you are perpetually two generations behind.
That’s not an AI problem. That’s an organizational learning problem. It existed before agentic coding showed up.
Agentic coding just made it lethal.
What the Knowledge Theorists Already Figured Out
I’m going to drag you through some academic stuff for a minute because it’s actually useful. Stick with me.
Back in the 90s Ikujiro Nonaka published the SECI model. Four modes by which knowledge moves through a company:
- Socialization — tacit to tacit. One person teaches another by working alongside them. Apprenticeship. Pairing. Watching how someone handles a problem.
- Externalization — tacit to explicit. You finally write down the thing you do by instinct. A blog post. A CLAUDE.md. A skill file.
- Combination — explicit to explicit. You take written things and merge them into bigger written things. Documents into specs. Specs into runbooks.
- Internalization — explicit back to tacit. You read the runbook, then you do the work, and now it’s in your hands and head.
Nonaka called this a spiral. Knowledge doesn’t sit still — when it’s working, it cycles continuously, getting richer each time around.
Image credit to https://thenextwavefutures.wordpress.com/2022/12/17/tacit-knowledge-high-value-work/
Here’s the bombshell: AI agents are absolute monsters at Combination. Genuinely better than humans, by orders of magnitude. Give them a pile of documents, specs, and tickets and they will synthesize, reconcile, and produce new documents faster than your best technical writer.
But AI agents cannot do Socialization at all. They cannot watch your senior engineer hesitate before a refactor and learn from the hesitation. They cannot smell when a junior is faking understanding in a code review. That’s tacit-to-tacit and it lives only in the room with the humans.
And AI agents have a weird shape on Externalization and Internalization. They can help you write the doc. They cannot make the doc true to your situation without a human in the loop. And they cannot internalize anything between sessions unless you wrote it down somewhere they can read.
So if you’re a leader trying to figure out how to make your adopt agentic coding as fast as possible — the answer is staring at you. Use the agents for what they’re good at (Combination) so your humans can spend their time on what only they can do (Socialization, judgment, real Internalization).
The Four Stages of Understanding
Now layer in the four stages of competence. Every engineer adopting agentic tools is somewhere on this ladder, whether they admit it or not:
- Unconscious Incompetence — “AI coding tools don’t really work.” They don’t even know what they don’t know. They may have tried it and were unimpressed, perhaps months ago.
- Conscious Incompetence — “Okay, this is real. But it needs to be carefully reviewed before we can use it.” This is where most thoughtful skeptics finally land.
- Conscious Competence — “I can get useful work out of it but I have to review everything.” Drafting prompts deliberately, reviewing every diff, building scaffolding.
- Unconscious Competence — Second nature. Reaches for the agent the way you reach for a debugger. Knows when to use it and when not to without thinking.
The four stages of competence arranged as a pyramid.
Here’s what I’m hearing about a lot: most leaders are at Stage 1 about AI tooling itself, but they’re issuing mandates as if they were at Stage 4. That’s how you get the “every PR must include AI-assisted commits” memos from VPs who have never personally run a coding agent. It’s also how you get the 22% number — only 22% of employees report that leadership has actually explained how AI will be applied at their company.
I’m a software leader. I’m going to be blunt with my peers: If you haven’t personally driven an agentic coding session for at least a week, you should not issue policy about it. You are Unconsciously Incompetent and you are about to make your team’s adoption harder, not easier. Sit down, open Claude Code or your tool of choice, and build something. Anything. Get to at least Stage 2 before you write the policy.
Knowledge Has Coordinates
The third framework worth knowing is Max Boisot’s I-Space. Boisot said knowledge sits in a three-dimensional space:
- Codification — how structured and formal is it?
- Abstraction — how general vs. specific is it?
- Diffusion — how widely has it spread?
His insight: knowledge can’t diffuse until it’s been codified and abstracted. The brilliant trick your tech lead figured out for handling agentic refactors of legacy code? Until they write it down (codify) in a form that generalizes beyond this repo (abstract), it cannot leave their head. It will not diffuse. It dies when they take a vacation.
This is the part that kills agentic adoption in most orgs. I’m seeing this my own organization. Every developer is figuring out their own tricks. Their own CLAUDE.md hacks. Their own skill scaffolding. Their own ways of getting good results. And none of it is being externalized, codified, or diffused. And the developers who are fastest are the ones spending nights and weekends using agents while their peer with a new baby at home are being left behind.
Because the only way to get the information into your head is by trying it. Even I hammer on this with my “you can’t learn to swim from a book” philosophy.
Separate people each learning the same lesson is not an organization learning. It’s separate people having (hopefully) identical private epiphanies. That does not scale.
And it’s not going to get your Engineering organization to be agentic coders.
Single-Loop vs. Double-Loop
Chris Argyris had another piece of this puzzle. Organizational learning comes in two flavors:
- Single-loop learning — “We tried X and it didn’t work, so let’s try Y to achieve the same goal.”
- Double-loop learning — “Wait, is the goal even the right goal?”
Almost every team I see adopting agentic tools is doing single-loop learning. They’re trying to write the same software they always wrote, just faster. Same architectures. Same processes. Same Jira tickets, just closed quicker.
Single-loop is fine. Single-loop is the floor.
But the actual unlock — the thing that makes a team a Dream Team in the agentic era — is double-loop. Questioning what work needs doing at all. Questioning whether your three-week design review process makes sense when an agent can spec the design overnight. Questioning whether you should be fixing that microservice at all when an agent can build the exact thing you need from scratch in a day.
And a real life thing: do we really want to write hundreds of new manual tests in Zephyr? Can we have an agent do this testing? Can we eliminate human testing completely? Why are we testing this thing like it’s 1999?
That’s the work. That’s the leadership work. And no agent is going to do it for you.
Submarines Already Solved This
I keep coming back to my Navy time. The Nuclear Power Program is the most effective learning organization I’ve ever seen, before or since. Think about what they actually do:
- Socialization is institutionalized. You qualify at every station by sitting next to someone who knows it, watching them, then doing it under their eye. Every watchstation. Every system.
- Externalization is mandatory. Every system has a manual. Every procedure is written down. Every casualty has a documented response. Even the informal knowledge — “old salts” sharing how they actually solved a problem — is captured in lessons-learned files and a process for fleet-wide sharing around incident reports.
- Combination happens in cross-training. Junior officers rotate through every department on the ship. Knowledge gets recombined in heads that span multiple domains.
- Internalization happens through drills. Constant drills. You don’t just read the casualty procedure. You execute it at 3am while exhausted, until even your fingers remember what to do even if you are still technically asleep.
The submarine community figured out a decades ago that running a complex ship requires every part of Nonaka’s spiral, deliberately staffed and resourced. And the cost of getting it wrong is everyone dies. That tends to focus the mind.
No PowerPoint required.
Your engineering organization doesn’t have lives on the line (hopefully). But the principle is identical: if you want your team to absorb new capabilities quickly and reliably, you have to engineer the knowledge cycle. It will not happen by accident.
What Actually Works
Enough theory. Here’s what I would tell any software leader trying to get their team learning as fast as the agents are improving:
1. Externalize aggressively, and externalize NOW
Every time someone on your team figures out something useful — a prompt pattern, a CLAUDE.md trick, an agent flow that works for your codebase — it goes into a shared place today. Not “I’ll document it later.” Later doesn’t exist. Later is where knowledge goes to die.
If your team has a dozen people each maintaining their own personal .claude/ directory and none of them are talking to each other, you have an externalization failure. Fix it. A shared skills repo. A #agent-tips channel that gets cleaned up into a wiki weekly. Lunch-and-learns where someone screen-shares their actual workflow. Whatever fits your culture, but it has to exist.
I’m guilty of this today. And I will fix that TODAY.
2. Combine the right way
Once you’re externalizing, combine. Take the personal CLAUDE.md files and merge them into the team standard. Take the working agent flows and turn them into team skills. This is the one part where you can absolutely use the agents to do the work — give Claude all of them and have it find the common patterns, the conflicts, the gaps. Combination is its superpower. Use it.
3. Socialize like the Navy
You cannot Slack your way to tacit knowledge transfer. Pair on agentic work. Real pairing. Two engineers, shared screen, working through an actual problem with an agent in the loop. The junior watches how the senior phrases the prompt, when they reject a suggestion, when they push back on the agent. None of that gets captured in a doc. It only transfers in the room. Trade back some of the saved coding time for explicit LEARNING TIME.
I’d go further: every team should be running something like the Navy’s qualification model for agentic work. You don’t get to claim “agent-fluent” by attending a training. You qualify by demonstrating it under the eye of someone who’s already there.
4. Force internalization through real work
Demos don’t teach anyone anything. Watching someone explain how they used an agent to build something is about as useful as watching someone else lift weights.
People internalize by using. Repeatedly. On real work. Until it’s Stage 4. Our job as leaders is to make sure they have the time, the safety, and the encouragement to spend that time. Which means accepting that some of their early attempts will be slower than just writing the code by hand. That’s the cost. Pay it. Sometimes you have to slow down to go faster. For this it’s totally true that you can’t learn to swim from a book.
5. Do double-loop learning at the leadership table
This is the one only you can do. Sit down with your peers and ask: given what these tools can now do, are we still building the right things? Is our process still right? Is our team shape still right? Are we still organizing around the assumptions of a decade ago?
If the answer to any of those is “we haven’t actually asked,” that’s your real problem. Not the tooling. Not the developers’ adoption rate. You.
Why Most Organizations Will Fail At This
Gartner says 85% of AI projects fail to deliver expected value. McKinsey’s number is uglier — out of 876 organizations surveyed, only 46 qualified as Gen AI high performers. That’s a 94.7% failure rate.
Those aren’t tooling failures. Tooling is 20% of the problem. The other 80% is people, process, and culture. Which is to say: organizational learning. Which is to say: whether you can run the SECI spiral fast enough to keep up.
The failure patterns I see or hear about:
- Leaders who haven’t crossed Stage 2 themselves issuing top-down adoption mandates
- Individual engineers learning brilliant tricks in isolation and none of it diffusing
- Externalization treated as optional (“we’ll document it later”)
- Single-loop learning dressed up as transformation
- Zero deliberate Socialization — everyone left to figure it out alone (this is where I am personally failing at the moment)
- A culture that punishes the early adopter’s productivity dip
Any one of those will slow you down. All of them at once is a death sentence in a market where the underlying tools are doubling in capability every six months.
In my own case, I didn’t want to “impose” new stuff on an already burdened team. But to get to internalization across my whole team, I may have to.
Conclusions
The agents aren’t actually learning faster than humans can. They’re not learning at all between sessions, except for what we explicitly persist for them. The reason they appear to learn fast is that the entire industry’s tacit knowledge has been externalized into training data, and then combined and re-served back to us as if it were always there.
That’s a process you can copy with humans. That’s literally what Nonaka described in 1991.
The teams that win the next five years aren’t going to be the ones with the cleverest prompts or the biggest token budgets. They’re going to be the ones who built a culture where one engineer’s Tuesday discovery is part of the team’s standard practice by Friday. Externalize. Combine. Socialize. Internalize. Spiral.
That’s not new. That’s just doing the actual work of being a learning organization, which most companies talk about and almost none of them do.
The good news is that the same agents that are forcing the issue are also the best Combination engine ever built. Use them on yourselves. Build the team that learns as fast as they do.
And if you’re a leader reading this who hasn’t personally driven an agent in anger this month — close this tab and go do that first. Seriously. This weekend. Everything else is downstream of you crossing Stage 2.
If this helps you, drop me a note on LinkedIn. And go pair with someone on your team today. Actually pair. Not Slack.
Further reading:
- SECI model of knowledge dimensions
- Four stages of competence
- I-Space conceptual framework
- Explicit knowledge
- Organizational learning