Get Smarter

Ever wanted to introduce a new AI agent to an established project? Get Smarter makes it easy — without fear of harming your existing codebase, and without you becoming the messenger.

Comment

Inspiration

I spent months building Medusa with Claude. It isn't just code to me — it's decisions, active work, safety strategies, and every lesson I learned the hard way after an agent confidently moved me backward more than once. I'm not a formally trained developer. My protection wasn't a test suite; it was context that lived in one long relationship with one agent.

Then OpenAI Build Week arrived and I wanted to see what Codex could do. Which raised a question I'd never seen anyone answer: how do you introduce a new AI agent to a project another AI built? If you've never heard how agents talk about each other, go ask Grok. Grok does NOT disappoint. I did not need any hyperactive know-it-alls deciding they each knew better and wreaking havoc in my codebase.

And the alternative was worse: me as the courier, copy-pasting months of context between chat windows, deciding what mattered, getting it wrong. Get Smarter exists because I refused to choose between "don't try the new agent" and "risk Medusa."

What it does

Get Smarter gives a new AI coding agent the briefing before it touches an established project.

Run npx get-smarter init . and it installs small, marked, preview-first pointers into the conventional instruction files for Codex, Claude, and Gemini — preserving whatever instructions the project already has. All three agents point at the same project-local coordination directory of structured Markdown records. A shared scanner validates those records and returns only the open messages addressed to the incoming agent. Resolving a message removes it from the next session's briefing, so nobody inherits a ghost task. A doctor command reports malformed records instead of guessing, and send generates schema-valid outbound messages so agents don't hand-author frontmatter at each other.

Three doors, one truth. The human stops being the messenger.

The proof that sold me: a completely cold Gemini session, history cleared, where the entire introduction from me was the word "hello." It found Claude's briefing, the project boundaries, and the one open message addressed to it — with zero courier work from me.

How we built it

We built it using the exact collaboration it makes safe. Codex with GPT-5.6 inspected the existing Claude-built project records read-only, reconciled Claude's context against the product boundary, then implemented the TypeScript scanner and CLI, the automated tests, and a privacy-safe public fixture. Claude and Codex never shared a chat window — they exchanged asymmetric context through repository records, which is the product demonstrating itself.

The result is a zero-dependency TypeScript CLI (Node 24+) with fourteen focused tests covering audience filtering, status lifecycle, malformed records, preview safety, path containment, and resolved-message disappearance. npm run demo copies a fictional months-old project to a temp directory and runs the full lifecycle deterministically, so judges never touch anyone's real data.

And it kept paying off in ways I didn't plan. Mid-build, I got rate-limited off my primary Claude model. Normally that's a dead stop — a new session with a different model knows nothing. With Get Smarter's briefings in the repository, I could hand work to Sonnet and it picked up the boundaries and open items without me re-explaining months of history. The tool built to introduce Codex ended up rescuing my own workflow.

Challenges we ran into

  • Two cold sessions flagged my own tool as a prompt injection. Fresh agents saw unexplained injected context and — correctly — got suspicious. Instead of explaining my setup live every time, we made provenance part of the product: every installed block identifies its source, limits its authority to the project root, and explicitly disclaims global hooks and external inboxes.
  • The first real npm package was a disaster caught just in time. Repository-local testing hid two failures: npm would have shipped 17.6 MB of video renders, and Node refused to run raw TypeScript from node_modules. We added a clean-tarball smoke test; the corrected package is about 14 KB and passes the full npx lifecycle.
  • Dogfooding exposed a half-built conversation. Agents could read and resolve messages but had to hand-author frontmatter to reply — token-wasteful and error-prone. That became the preview-first send command.
  • Restraint under deadline. The most dangerous temptation was letting the tool touch Medusa to make a better demo. It never did. The public fixture carries the whole demonstration.

Accomplishments that we're proud of

  • The "hello" test: a cold agent recovering a full project briefing from a one-word greeting.
  • Get Smarter did not modify Medusa. The thing it was built to protect stayed protected, all the way through submission.
  • A fresh clone of the public repo passes all tests and the judge demo with zero dependency installation — and the package is published, so npx get-smarter init . is the real public command, not a promise.
  • Preview-first everywhere: nothing writes without showing you first, everything is marked and reversible, and resolution is trapped inside the coordination directory.
  • The origin story is real, sanitized evidence — an actual rejected unsafe strategy, an actual dirty-file collision caught, an actual fresh worker in an isolated worktree — not a staged demo.

What we learned

Onboarding an agent isn't a memory problem — it's a trust problem. The breakthrough wasn't shared context; it was clear ground rules and reversible boundaries that let me use an unfamiliar agent's strengths without fear. Capable agents don't need to duplicate each other's reasoning; they need the asymmetric context the other one uniquely holds, and a place to put real exceptions.

I also learned that safety features come from watching real sessions, not imagining threats. The provenance guarantees exist because cold agents distrusted my tool, and the send command exists because dogfooding hurt. Every safeguard has a story.

And I learned that the human-as-courier role I'd accepted as normal was actually the biggest risk in my workflow — lossy, biased, and exhausting.

What's next for Get Smarter

  • The controlled three-chat cold start: fresh Codex, Claude, and Gemini sessions given the same read-only question, comparing what each recovers.
  • Stale and unaddressed-message diagnostics, so doctor catches drift, not just malformed records.
  • The fuller lifecycle: repository-wide validation, status management, and tidy — cleanup that leaves the smallest trustworthy orientation set for the next session.
  • Executable task packages: structurally validated handoffs that carry their own checkpoint, file allowlist, and authorization contract, so an agent can safely execute — not just read — what another agent left behind.
  • Native editor hooks as delivery optimizations. The conventional instruction-file path already crosses agent and IDE boundaries; hooks just make it smoother.

Your next agent shouldn't meet your project as a stranger.

Built With

Share this project:

Updates