Skip to main content
Test Double company logo
Services
Pragmatic Services Overview
Holistic software investment consulting
Acccelerate Software Delivery
Balance efficiency and quality
Improve Product Impact
Drive results that matter
Upgrade Rails Seamlessly
Update Ruby and Rails versions
Scale DevOps
Dev experience and infrastructure
Technical Recruitment
Build tech & product teams
Case Studies
Solutions
Legacy Modernization
Renovate legacy software systems
Pragmatic AI
Solve business problems without hype
Technical & Product Assessments
Uncover root causes & improvements
About
About
What's a test double?
Approach
Meeting you where you are
Founder's Story
The origin of our mission
Culture
Culture & Careers
Double Agents decoded
Great Causes
Great code for great causes
EDI
Equity, diversity & inclusion
Insights
All Insights
Hot takes and tips for all things software
Leadership
Bold opinions and insights for tech leaders
Developer
Essential coding tutorials and tools
Product Manager
Practical advice for real-world challenges
Say Hello
Test Double logo
Menu
Services
BackGrid of dots icon
Services Overview
Holistic software investment consulting
Software Delivery
Accelerate quality software development
Product Impact
Drive results that matter
Cycle icon
DevOps
Scale infrastructure smoothly
Upgrade Rails
Update Rails versions seamlessly
Technical Recruitment
Build tech & product teams
Case Studies
Solutions
Solutions
Legacy Modernization
Renovate legacy software systems
Pragmatic AI
Solve business problems without hype
Technical & Product Assessments
Uncover root causes & improvements
About
About
About
What's a test double?
Approach
Meeting you where you are
Founder's Story
The origin of our mission
Culture
Culture
Culture & Careers
Double Agents decoded
Great Causes
Great code for great causes
EDI
Equity, diversity & inclusion
Insights
Insights
All Insights
Hot takes and tips for all things software
Leadership
Bold opinions and insights for tech leaders
Developer
Essential coding tutorials and tools
Product Manager
Practical advice for real-world challenges
Say hello
Developers
Developers
Developers
AI

Accelerate your understanding of unfamiliar code with AI Part 4 - Slope of Growth

On the Slope of Growth, AI resumes heavy lifting safely once verification loops and durable documentation become habits, keeping your codebase correct and team knowledge shared.
River Lynn Bailey
|
November 19, 2026
Thank you! Your submission has been received!
Oops! Something went wrong while submitting the form.

"I'm starting to get this." Back to baseline with the AI helping a lot

Part 4 of 5. On the Slope of Growth, the AI goes back to doing the heavy lifting. That's safe now, because you can check every claim it makes against code you can open, and then write down what you checked.

‍

This series follows what happened to me during one week of effort on a single work ticket, in a system I'd never seen before. On the first day, Claude Code explained the code the ticket touched, and I felt like I understood it. Once I started on the change, that explanation stopped being enough, and I fell from the Peak of Confidence into the Valley of Realization. I spent the middle of the week working through the change one step at a time, with Claude as a mentor while I wrote the code myself.

Late in the week, the ticket started moving again. Not at the speed of the first day, but at something close to my normal pace, and with Claude doing a lot of the work again. The difference wasn't in tooling, though. When Claude told me something about the system, I knew where to look to see whether it was true.

Getting back to your normal pace of development is the Slope of Growth, the stretch of the confidence curve often labeled "Dunning-Kruger" that climbs out of the valley. The feeling to look for is "I'm starting to get this." What gets you there is a habit: checking what the AI tells you against the code before you rely on it.

The verification loop is the habit that carries you

The habit to build has a name in the research: a verification loop. In a study by Qiao and colleagues, fifteen graduate students implemented features in an existing codebase, with and without GitHub Copilot. With Copilot, the students finished the features faster and with fewer errors. But Copilot didn't help them understand the codebase any better: on the comprehension tests, the students scored the same with Copilot as without it.

What separated the students who understood the code from the ones who didn't was not the tooling itself, but how they used it. Verification loops, where the student stopped to review the generated code, predicted comprehension almost perfectly. Students who understood the code best reviewed what Copilot wrote nearly five times as often as the students who understood it least.

‍Anthropic's study of engineers learning a new library points the same way. The engineers who used AI scored 50% on a comprehension quiz, against 67% for those who coded by hand. Among the AI users, the ones who asked the assistant conceptual questions, or asked it to explain the code it generated, averaged 65% or higher on the quiz. The ones who allowed the AI tooling to write the code averaged under 40%. In both studies, the people who built an understanding of the code were the ones who questioned and reviewed what the AI produced, rather than handing it the work.

To work through the Slope of Growth, then, you need to check both the AI's explanations of existing code against the source, and the code it generated. That step is the most important one, and the easiest to forget or drop once the code is working. But it must be made into a habit: every time the AI makes a claim, open the file it names and confirm it.

Letting the AI do the heavy lifting again

Once that habit is in place, the pace can change. In the Valley of Realization, you stopped after every small step to review and ask questions. Now, on the Slope of Growth, you can let the AI tooling run a complete change, a full investigation, or an entire code review, then review the result the way you'd review any change. This is only possible when certain conditions are met, though:

  • You understand the current code and concepts where the change will happen, because you've worked through it one step at a time
  • You've worked your way out of the Valley of Realization, which means you can tell when the AI gets something wrong
  • You know the system it's changing, and why the change is being made in that specific manner

‍

And this means you can slowly work up to letting the AI write and analyze code at full speed again.

What keeps this safe is the habit of a verification loop combined with output that points at the code changes. A finding tied to a file and a line is one you can open and confirm. And verifying those changed files is fast now in a way it couldn't have been on the first day, because you know where to look. Knowing where to look took real work, and it's worth writing down for your own sake and for anyone else that needs to work on the code later.

Make it durable, so nobody pays twice

The first day's explanation may have lived in a scratch file, with everything you've learned since living in your head and/or a chat session. If it all stays there, the next person to touch this code pays the full cost of building that understanding again. And experience tells you that "the next person" might be you, months from now, after you've forgotten how the code works and why. Combine that with understanding how an AI model will likely explain the same code a little differently each time it's asked, and you've got a recipe for repeating work that's already been done, every few months.

To solve that problem, write the understanding into the repository or document management system, instead. And do so with the document grounded in the real source code, with both an explanation and with examples that point to the real code. Then reference it from CLAUDE.md or AGENTS.md, so every later session, human or agent, knows where it lives. Claude Code loads CLAUDE.md at the start of every session and expands @path imports into context. This means we have options for how and when Claude loads that information. A plain Markdown link is a pointer the session can follow when it needs to. But if you want the document in every session's context, import it with @docs/your-feature.md and it will be immediately loaded into context.

Writing and loading the document aren't enough on their own, though. As code changes, references in documentation become stale. And eventually, developers ignore the documentation because they know it's out of date. Check the document against the code, regularly, the same way you checked every other claim the AI made. Make corrections when you see something is off — and if you can, automate documentation updates via the AI tooling you have available. A correction made to a document in the repository is made for everyone who reads it later, human or AI.

Maintaining documentation also raises the team's bus factor: the number of people who'd have to leave before a project is in trouble. One way of measuring bus factor uses commit history to find the smallest group of developers who, between them, wrote most of the code. If they leave, no one left on the team has worked on it. Documentation keeps that knowledge from leaving with them. A document that's been checked against the code and referenced from a known location moves the understanding out of one person's head and into an artifact anyone can read and update.

Pitfalls on the slope

Unfortunately, lack of documentation is only one of the pitfalls you can run into when working your way up the Slope of Growth. Once the AI tooling is doing most of the work again, the speed may come back, but so does the temptation to stop checking the AI's claims or updating the documentation. Each of these pitfalls trades that work for speed.

  • Dropping your newly built habits. In METR's trial, experienced open-source developers working in repositories they knew well felt 20% faster with AI, yet were measured 19% slower. The feeling of speed isn't evidence of speed, and the slope is where that feeling comes back. Don't let it convince you to stop checking the AI's claims against the code. That habit is what creates and maintains real speed, for you and for anyone else working in this code.
  • Documenting from memory instead of from the source. Your memory of the system is the thing the document is supposed to check, not the other way around. Write documentation from the code and verify it against the code, or it risks carrying your misunderstanding forward to everyone who reads it.
  • Not maintaining the documentation. Writing documentation is tedious at best, and it often feels like repeating what anyone could learn by reading the code. That feeling is a sign you're optimizing for yourself, today. You may know exactly how the code works, and why, in the moment. But what about a week from now, or a month from now? And what about the developer who's stepping into this code for the first time? Keep the documentation checked against the code and up to date, and automate the updates wherever you can.

Tools for the slope

Automating the documentation work is where tooling helps most on the slope. Han, an open-source set of Claude Code skills, has skills that write documentation from the source and keep it current.

  • /project-documentation writes a document for a feature, system, or component by reading the code, and adds a reference to it in CLAUDE.md or AGENTS.md. Run it again after the code changes, and it updates the existing document to match the current source.
  • /project-documentation-to-confluence does the same work and publishes the result to a Confluence page, for teams that keep their documentation there.
  • /architectural-decision-record records a decision with its context, the alternatives that were rejected, and the reasons, in a form that outlives the people who made it.
  • /coding-standard creates or updates the project's standards and conventions, so every later session and reader follows the same rules.
  • /edit-for-readability rewrites a document's prose so the main point comes first, while preserving every fact in it.

‍

None of these skills replace the checking, though. A generated document is one more set of claims about the code, and it gets the same treatment as every other claim: open the files it names and confirm what it says. Every phase in this series has come down to those two steps, running the tool and verifying what it produced. The tooling makes the work fast and cheap. Verification is what makes it correct.

The skills aren't the workflow

On the Slope of Growth, the AI begins doing most of the work again. Unlike the first day of coding in the Peak of Confidence, the AI tooling can now handle these tasks because you've already taken the time to build your understanding, and ensure it's written down and maintained. This makes it easier for you to see when the AI tooling is doing something wrong, because you have a solid mental model of how the code works and what the changes should look like.

Part 5 moves beyond the Slope of Growth, and into the Plateau of Mastery. Here, the AI moves from only doing the tedious or baseline work and begins to shape the changes that will be made. The habits and processes that got you to this point don't go away, though. Instead, they change shape before they start getting in the way.

‍

River Lynn Bailey is a Senior Software Consultant at Test Double, and has extensive experience in AI coding tools and delivery, built on a career of delivering quality software solutions

AI Insights and More

Sign up for the Test Double newsletter to receive more tips for pragmatic AI approaches.

Subscribe

Related Insights

🔗
Accelerate your understanding of unfamiliar code with AI
🔗
Accelerate your understanding of unfamiliar code with AI Part 2 - Peak of Confidence
🔗
Accelerate your understanding of unfamiliar code with AI Part 3 - Valley of Realization

Explore our insights

See all insights
Developers
Developers
Developers
Accelerate your understanding of unfamiliar code with AI Part 3 - Valley of Realization

When AI explanations aren't enough, you enter the Valley of Realization. Learn how to use AI as a mentor rather than a coder so you can build real understanding of unfamiliar code.

by
River Lynn Bailey
Developers
Developers
Developers
Accelerate your understanding of unfamiliar code with AI Part 2 - Peak of Confidence

AI tools make exploring unfamiliar codebases feel effortless, but that fast explanation creates an illusion of depth. Learn how to leverage AI safely without falling into the peak of confidence trap.

by
River Lynn Bailey
Developers
Developers
Developers
Accelerate your understanding of unfamiliar code with AI

AI makes exploring unfamiliar code faster than ever, but speed isn't understanding. Discover how to bridge the gap and truly master a new codebase in Part 1 of this 5-part series.

by
River Lynn Bailey
Letter art spelling out NEAT

Join the conversation

Technology is a means to an end: answers to very human questions. That’s why we created a community for developers and product managers.

Explore the community
Test Double Executive Leadership Team

Learn about our team

Like what we have to say about building great software and great teams?

Get to know us
Test Double company logo
Improving the way the world builds software.
What we do
Services OverviewSoftware DeliveryProduct StrategyLegacy ModernizationPragmatic AIDevOpsUpgrade RailsTechnical RecruitmentAssessments
Who WE ARE
About UsCulture & CareersGreat CausesEDIOur TeamContact UsNews & AwardsN.E.A.T.
Resources
Case StudiesAll InsightsLeadership InsightsDeveloper InsightsProduct InsightsPairing & Office Hours
NEWSLETTER
Sign up hear about our latest innovations.
Your email has been added!
Oops! Something went wrong while submitting the form.
Standard Ruby badge
614.349.4279hello@testdouble.com
Privacy PolicyTerms & Conditions
© 2020 Test Double. All Rights Reserved.

AI Insights and More

Sign up for the Test Double newsletter to receive more tips for pragmatic AI approaches.

Subscribe