AntiVibe is a Claude Code skill that turns any codebase into an educational deep dive. It explains the design decisions and trade-offs behind new or legacy code so you can understand the actual logic instead of just copying snippets.

https://github.com/mohi-devhub/antivibe https://x.com/tom_doerr/status/2083687949682590206

Everyone is talking about the OpenAI agent that attacked Hugging Face.

The bigger question is simple. Could anyone have seen it coming?

Yes, if iFixAi had been run on that agent first.

That is the whole job. You point it at your agent before it goes live and it surfaces the risky behaviour early, before the agent goes rogue.

45 checks, an A to F grade in 120 seconds, free and open source, and it runs inside Claude Code, Codex and Cursor.

Catch it on your own screen while it is still just a bad score.

Google and Anthropic agree on one thing about retrieval.

They both moved it out of the app and turned it into a standalone service that agents invoke.

- Anthropic's MCP exposes retrieval as a tool that an agent invokes.
- Google ships it similarly, with its RAG Engine sitting under the Gemini agent platform next to MCP servers.

They did this because the old naive RAG setup was built as a one-time pipeline inside a single app, and it caused problems in two places:

- The first is stale embeddings. They reflect the source at indexing time, so the index drifts from the source when a doc or a row changes, and stays wrong until the pipeline is rerun.

- The second is coupled infrastructure. The retrieval logic sits inside one app, so another app duplicates the connectors, chunking, and embedding instead of reusing them.

Both failure modes are resolved by separating ingestion from query and running ingestion as a standing layer.

Ingestion runs continuously with content-hash sync, so only changed data is re-embedded, and the layer sits behind one API, so a chatbot and an agent hit the same index.

The agent then calls that layer as a tool inside a loop. It reasons, runs a search, reads the result, and issues a refined query, instead of retrieving once at the start.

The diagram below depicts all three stages, covering naive RAG, the standing layer, and the agent consuming it.

This helps, but it didn't solve all problems yet because across all three stages, the unit of retrieval is the same, i.e., a chunk of text.

And inherently, a chunk has no idea of a semantic boundary, version, or source info. The splitter cuts documents mostly on token count, so a single chunk can end mid-table or mid-argument.

Because of that, it can pull the top half of a table without the rows, or a conclusion without the reasoning that supports it.

Moving to a structured unit, embedding a question with its validated answer, addresses this.

I wrote wrote a full breakdown on solving this. It replaces raw chunks with structured blocks that carry their own source and version.

The approach reduces corpus size 40x and improves vector relevance 2.3x.

Read it below.