In The Debt We Didn't See Coming, @ivanetchart wrote about cognitive debt—the gap between what a codebase does and why it's shaped that way. What he didn't cover is the human side: the people who are supposed to close that gap, and what happens when the path to learning gets blurred.

Why we do this

We solve problems. We build things. But that's not the whole story.

Crunchloop exists because four of us wanted to share a way of working. Not just deliver software—share the thinking behind it. Watch people grow. See someone struggle with a concept, then own it. That's the part that makes the work worth doing.

This isn't sentimental. It's operational. Our reputation is built on expertise and care. When we bring someone into a project, we're not just adding capacity—we're putting our judgment on the line. That's why teaching matters. Not as a nice-to-have. As the mechanism that makes the whole thing work.

What changed

When I started in 2011, Uruguay's software industry was growing, mostly serving US clients. Things were more informal. CI pipelines weren't common. Testing wasn't deeply embedded in the process. Infrastructure was something mystical—juniors didn't touch it. And language? A barrier, yes, but one you could work around. Someone with more experience would talk for you.

None of that flies today. You're expected to own your CI. Write your tests. Understand the infrastructure your code runs on. Speak directly to the client. No one talks for you anymore.

The bar moved. That's not a complaint—it's context.

Now it's moving again, but faster, and in a stranger direction.

Juniors today will learn to use AI. That's inevitable. What's not inevitable is whether they'll learn what's underneath. The concepts. The reasoning. The why behind the what.

I call this AI noise: you shipped it, but you can't explain it.

I saw this recently in a technical interview. The task was straightforward—a CRUD from scratch, a model with a relation. The candidate opened their AI tool and typed: "add the model." No planning. No attributes. No mention that this model couldn't exist without its parent.

Later, I expected them to ask the AI something—clarify a behavior, explore an edge case. Instead, another instruction. No dialogue. No thinking out loud. Just commands.

The model was a dependent resource. When I asked how it should behave without its parent, they guessed wrong. The AI had handled it correctly—they just didn't know what their own code did.

I gave feedback: no planning, no specification, no control over the outcome. The response was a mix of excuses—"it's not a big enough feature to require all that"—and a quiet realization. The outcome wasn't in their control.

That's AI noise. The code worked. The understanding didn't.

This isn't a junior problem. It's amplified for juniors, but it affects everyone. Cognitive debt, as @ivanetchart described it, is the organizational version. AI noise is the individual version. They compound.

What we're navigating

We love to teach. We love to see people grow. But teaching requires access—time with people, visibility into how they think, moments where you can intervene before a small misunderstanding becomes a permanent gap.

That access is getting harder to create.

Move too slow, and you can't compete. Move too fast, and people learn to produce without learning to think. The easy answer is to stop caring about the people and just trust the AI output. That's not our answer.

We believe—for now, and I won't claim this is permanent—that AI can do the heavy lifting on code and execution. Even planning. But people remain accountable. And accountability requires trust. Trust has layers: we don't expect the same things from someone with fifteen years of experience and someone with fifteen months. But in both cases, the foundation is the same. We need to trust our partners and collaborators. That trust has to be earned, and earning it requires actual understanding—not just output.

What Dap makes possible

The problem isn't new. What's new is that we now have the infrastructure to address it.

Dap gives us visibility we never had before. Day by day, action by action, we can see how developers work. What questions they ask. How deep those questions go. Whether they're engaging with the hard parts or skating past them. Whether they're building understanding or just building artifacts.

This isn't surveillance. It's the foundation for teaching at scale.

When you can see patterns—this person consistently avoids testing, that person doesn't ask clarifying questions, this team rushes past architecture decisions—you can intervene. Not with generic training. With specific, contextual guidance. The kind of teaching that actually changes how people think.

We're not there yet. We're building the blocks. But the path is clear.

What's coming

There's a piece of this we haven't talked about publicly yet. We're calling it the Dap Brain—a way to create collective memory across projects and people. To understand not just what happened, but how things relate. Who worked with whom. What patterns emerged. Where knowledge gaps cluster.

@ivanetchart will have more to say about this. For now, I'll just say: if cognitive debt is the problem, and AI noise is making it worse, the Dap Brain is how we plan to fight back. Not by replacing human judgment, but by making it easier to develop.

Open questions

We don't have this figured out. Some things we're still working through:

How do you measure learning, not just output? We can see what people produce. Seeing what they understand is harder.
What's the right moment to intervene? Too early feels like micromanagement. Too late and the gap has already formed.
Can this scale without becoming impersonal? The whole point is human connection. If Dap just becomes another dashboard, we've failed.
How do we avoid the trap of optimizing for legible signals? The developers who ask the best questions might not be the ones who look best in the metrics.

Closing

AI noise is real. It's making learning harder at the exact moment when learning matters most.

We're not going to solve this by ignoring it, and we're not going to solve it by abandoning people to figure it out alone. We're going to solve it by building tools that make teaching possible again—at scale, with context, without losing the human element that makes it work.

That's the signal under the noise. That's what we're building toward.