Paste Error, Zero Learning (Anti-pattern)

AI accelerates your existing workflow. If your workflow is "see error → get fix → ship it," AI makes you faster at that workflow. But the workflow is wrong. The correct workflow is "see error → read it → form a hypothesis → ask a targeted question → understand the answer → apply and verify." AI accelerates the middle steps; the diagnosis and verification are yours.

The rubber duck pattern: describe the problem to yourself before describing it to the model. The description forces a hypothesis. Then use AI to validate or refute it:

• "I think [X] is causing [Y] because [Z]. Is that right?" — validates your reasoning
• "I expected [A] but got [B]. What am I missing about how [concept] works?" — fills knowledge gaps
• "The fix is [patch]. But is this addressing the root cause or just the symptom?" — catches shallow fixes

When the model answers, verify the explanation makes sense. If you can't explain the fix to a colleague in two sentences, you don't understand it yet.

The failure mode was not that the agent used AI — it was that the agent's error-handling strategy was "include everything and let the model sort it out." For a 214-line compiler output, that strategy consumed roughly 4,000 tokens per turn, 24,000 tokens across six turns, just in error text. A structured parser that extracted the first diagnostic per file (file path, line, error code, message) would have produced a 19-line summary: around 400 tokens, leaving the context window for actual code fixes.

The structural principle: an AI agent's effectiveness is bounded by the signal-to-noise ratio of its inputs. Raw tool outputs — compiler errors, test failures, linter results, stack traces — are high-noise. The agent's job is not to parse noise; it is to reason about signal. The pipeline stage that runs the tool should also produce a structured summary of the result. This is not a limitation of AI — it is good engineering practice for any automated system that processes tool output.

In diagnose mode, the AI asks a follow-up question. That's the signal you entered a diagnostic conversation rather than a vending-machine fix loop. Follow-up questions mean the model has enough context to be specific.

Error summarisation in agentic loops should be a first-class pipeline stage, not an afterthought. For TypeScript specifically, tsc --noEmit --pretty false produces machine-parseable output without ANSI escape codes. Pipe it through a digest function before the output reaches the agent's next prompt. For test runners, most support --reporter json or --reporter tap — structured output that can be summarised without regex.

// Agentic loop: run tool, summarise, pass digest to model
async function runWithDigest(command) {
  const { stdout, stderr } = await exec(command);
  const raw = stdout + stderr;

  if (command.startsWith('tsc')) {
    return parseTscOutput(raw);      // ~400 tokens
  }
  if (command.startsWith('jest') || command.startsWith('vitest')) {
    return parseTestOutput(raw);     // failed tests only, summary counts
  }
  // Fallback: first 50 lines + line count
  const lines = raw.split('\n');
  const head = lines.slice(0, 50).join('\n');
  return lines.length > 50
    ? `${head}\n... (${lines.length - 50} more lines truncated)`
    : head;
}