Guides

All guides

• Cursor, Claude Code, Cline — why does the same model feel completely different in each?

  The harness is what's actually different — and most platform comparisons miss it.

• Your model got smarter and your answers got worse. Why?

  The multiplicative principle, the degradation curve, and why upgrading models without auditing context backfires.

• Why can't your AI agent answer 'how did we get here?' even when it has all the data?

  Two failure modes of LLM temporal reasoning, and why long context isn't the fix.

• Why does every new hire ask the same questions even when you have the docs?

  The institutional memory problem isn't a documentation problem. It's a provenance problem.

• When should you stop adding chunks to your RAG and reach for a knowledge graph?

  The signal that you've crossed a Class A/B boundary — and what a hybrid context layer actually looks like.

• Why does RAG keep failing on questions about your team's history?

  The reason RAG works for FAQs and breaks for decision history — and what to do about it.

• When you have several vector stores, how do you send a query to the right one?

  Why a merged store wrecks precision, why if/else routing is brittle, and the retriever-tool pattern that fixes both.

• What's the smallest RAG pipeline that actually works — and why is it exactly one LLM call?

  The Query-Retrieve-Augment-Generate flow, the single-LLM-call invariant, and why grounding is a prompt-template discipline, not a bigger model.

• Your RAG answers are wrong. Is it the model — or your chunking?

  Most "RAG doesn't work" reports are chunking problems, not model problems. Here's why chunking is the single biggest quality lever.

• What should your agent do when every retriever tool comes back empty?

  Agentic RAG has a hole: no defined behavior when retrieval fails. The Retrieve-Check-Route pattern closes it.

• When your RAG finds nothing relevant, should it stay silent or fall back to the model?

  Treating retrieval as an unconditional prefix to generation is the bug. Make generation conditional on a relevance decision.

• Should the agent decide what to retrieve, or should the pipeline?

  Fixed retrieval fetches the same three chunks for every question. An agent that chooses gets the hard ones right and the easy ones expensive.

• Should one agent do the whole job, or should you split it?

  Splitting work across harnesses helps for reasons that have nothing to do with model quality — and hurts for reasons nobody budgets for.

• How locked in are you to your AI coding tool?

  Switching cost in agentic tooling doesn't sit in the code. It sits in the accumulated context you'd have to rebuild.

• Was that the model, or was it the harness?

  Agent benchmarks measure two things and report one number. Separating them changes what you should buy.

• Why does your agent forget everything between sessions?

  Nothing survives a session boundary except what got written down. Most setups write down the wrong things.

• Is this a prompt, or is it a skill?

  The line isn't length or polish. It's whether the thing carries its own judgement about when to apply.

• Why does your agent say it's done when it isn't?

  "Done" set by intention rather than evidence is the quietest way a long run accumulates breakage.

• Which model should this task actually use?

  Picking the top of the tier list for everything is the expensive way to get worse latency and the same answers.

• Why does your agent keep following a rule you retired?

  A flat instruction file has no way to say 'this used to be true'. So the oldest line competes with the newest on equal terms.

• What should an agent read at the start of a six-hour run?

  Four files, separated by how often each one changes — and a rule about which of them wins.