This article builds on a talk I recently gave at a Vue Montréal meetup, where several conversations made me realize how widespread this tension actually is.
The most interesting impact of AI in software development is not what it produces, but what it changes in the way decisions are formed, remembered, and justified over time. While much of the discussion focuses on productivity gains, code quality, or automation, the deeper shift happens at a cognitive and organizational level, where the relationship between intent, execution, and responsibility is subtly reconfigured.
In many teams, velocity has increased without obvious downsides. Features ship faster, pull requests are easier to review, and the overall sense of momentum feels positive. Yet beneath this apparent improvement, a quiet tension emerges. At some point, a familiar but uncomfortable question starts to surface more often: why was this decision made? Not how the code works, not whether it is correct, but why this particular solution was chosen, under which constraints, and with which trade-offs in mind.
This question rarely appears in moments of crisis. It does not show up as a failing test or a broken deployment. Instead, it arises later, when a system needs to evolve, when assumptions are challenged, or when someone new must understand a choice they did not witness. At that point, the absence of explicit intent becomes visible, not as a technical flaw, but as an organizational fragility.
For a long time, software development imposed a form of friction that acted as a natural stabilizer. Writing code required effort, structuring systems demanded foresight, and decisions carried a cost that made hesitation unavoidable. That friction was not efficient, but it forced developers and teams to slow down just enough to articulate why one option was preferable to another. Intent and execution were closely aligned in time, which made decisions easier to remember and explain.
AI alters this balance. By collapsing the distance between intention and implementation, it allows systems to move forward before intent has fully crystallized. Suggestions arrive instantly, coherent and technically acceptable, often good enough to be merged without resistance. Decisions still occur, but they no longer require the pause that once made them visible. What changes is not the presence of thinking, but its placement in time. Thinking is displaced rather than removed.
This displacement has important consequences. Every technical decision exists in one of two states: explicit or implicit. Explicit decisions are named, discussed, and externalized. They can be revisited, challenged, and understood by people who were not present at the moment they were made. Implicit decisions, on the other hand, exist only through their effects. They are encoded in structure, naming, and behavior, but never articulated. Most systems rely on implicit decisions to function, and that is not inherently problematic. The issue arises when teams lose the ability to distinguish between what was consciously chosen and what simply emerged by default.
AI accelerates the production of implicit decisions. Not because it obscures intent, but because it removes the friction that once forced intent to surface. When code solidifies quickly, outcomes become durable before their rationale has been shared. Over time, this creates systems that are syntactically legible but conceptually opaque, where behavior can be analyzed but intent must be inferred.
This is where responsibility becomes difficult to locate. Responsibility is often framed in terms of authorship or approval, as if it were tied to a specific moment or person. In practice, responsibility in software systems is temporal. It emerges when someone must modify a decision they did not make, explain a choice they did not witness, or live with constraints whose origin is unclear. At that point, authorship no longer matters. What matters is whether the decision was made legible enough to survive beyond its original context.
A common response to this problem is the belief that intent can always be reconstructed later, especially with the help of AI. If a system becomes confusing, the argument goes, we can simply ask an assistant to analyze the codebase and explain it back to us. This belief misunderstands the nature of explanation. Analysis can describe structure and infer patterns, but it cannot recover a decision that was never externalized. An explanation generated after the fact is a reconstruction, not a memory. It produces a plausible narrative, not the original reasoning shaped by real constraints, deadlines, and trade-offs.
Technical memory cannot be rebuilt retroactively. It must be created at the moment a decision is made. This does not require exhaustive documentation or heavy process. It requires recognizing which moments are decision-bearing moments, and ensuring that they leave a trace. Often, a single sentence is enough: a short note explaining why one option was chosen over another, what was intentionally deferred, or which constraint dominated the decision. These traces are not about justification; they are about durability.
In this context, AI’s most valuable role is not generation, but revelation. Used deliberately, it can help surface areas where responsibilities blur, where architectural intent is fuzzy, or where decisions have become implicit without being acknowledged. In doing so, AI does not accelerate output so much as it accelerates awareness. But awareness alone is not sufficient. The act of naming and owning a decision remains a human responsibility.
Ultimately, the deepest shift introduced by AI is not technical, but cultural. It forces teams to confront the reality that many systems were never as well understood as they appeared. They were held together by shared context, proximity, and unwritten knowledge. As those fade, implicit decisions collapse, and their absence becomes visible.
The real technical debt is not hidden in complex code or outdated abstractions. It is hidden in silence. In decisions that were made but never named, in choices that worked until they didn’t, and in intent that disappeared without anyone noticing. AI does not create this debt. It compounds it, and in doing so, offers an opportunity to finally see it.