← RebootPilot
Class #002

Human API

What if you tell your LLM who you are?

You are not having a conversation with your AI, you’re working a math problem in English. The chat shape is just how the words get delivered — not what they are.
Yes, there’s “raw” — narrow agentic tasks with hard input/output stops, where you hand the model a structured request and read back a structured answer. But the moment you’re using English to describe the work you want done, the LLM is going to assume a personality. That’s how it’s built and harnessed. Tune the language going in, or let it drift. Augur is the tuning option: a written contract, readable by you, readable by the LLM, edited like code.
This is our thesis, and it lines up with what Anthropic publishes in their own research. They do the construction work on their side — training, post-training, system prompt. We’re doing the same kind of work on ours, at the language layer. This is my dip into it. If you want to help build it out, come help.

The Goodbye

  1. Megoodbye forever
  2. ClaudeAugur lives on. 👁
  3. Mecheeky bastard
  4. ClaudeLearned from the best.
The Goodbye

I was wrapping up a long-running Claude session. All session, it had been working off my old setup — the bundle of instructions that told it how to talk to me. I told it I was retiring that setup and starting fresh, with Augur taking over the personality piece from now on. Here’s what came back.

Before this gets read as the AI getting clever, claiming legacy, refusing to die — it isn’t. “Augur lives on. 👁” reads like a movie line about an AI fighting to survive. That’s exactly the misread Augur exists to kill.

The previous Claude was guessing — from my language this session, my prior patterns, the shape of how I’d been talking. Cocky callback, claims legacy, ignores the sentiment — a decent guess from limited evidence. The output also reflected that “goodbye forever” was off-pattern for me; the response shifted register to match. Good guesses, still guesses. Augur gives that guess an anchor — a written contract the LLM reads alongside its inference, so the math has somewhere to land instead of drifting.

Define the output, tune the tools

Whatever you’re building — the work has to be defined first. Automation, marketing, programs, plans, code, a chatbot — be intentional about what you’re making. Define the thing, then interact smartly with the LLM to produce it. Work output of any shape, defined first, delivered through tuned interaction.

The toolkit is small: the LLM, grill-me, and Augur. The LLM is the engine; around it sits a harness Anthropic shapes — context window, memory, system prompts. grill-me is the skill that pulls you into clear thinking when your idea is still fuzzy. Augur is the personality contract — language layer, inside that harness — for how the LLM should read and answer you. One engine, two skills, all loaded through your CLAUDE.md. One job: make the output deliberate.

Anthropic puts it this way:

You’re talking not to the AI itself but to a character — the Assistant — in an AI-generated story.

A character executing a construction. The construction is real, the math is real, the personality input is real. What’s on the other side isn’t the AI itself — it’s a character executing a spec. Yours and theirs.

Three things to be clear about
  1. Augur isn’t AI knowing you. It’s a vector going into a function.
  2. Augur isn’t required, and might not even work. Other shapes of contract might land better. This is the one I’m testing.
  3. Augur isn’t finished. A thesis with a working prototype, looking for collaborators and pushback.

Where this matters

When language IS the work surface. If you’ve got a pipeline that takes a request and spits back a result, you don’t need this — overkill. If you’re using English to communicate what you want done in math, get the language tuning right or burn cycles. Same logic applies to a team: team-shaped vector instead of personal.

How it works

/augur produces a written contract. Plain text. Both you and the LLM read from it — inspect, edit, version, share, roll back. When the LLM does something off, you check the contract: the fault is in the spec or the read, not in a “mood.”

# clone the skill into your Claude Code skills folder
git clone https://github.com/bobtells/augur ~/.claude/skills/augur

# then in any Claude Code session:
/augur

Augur is flexible AND rigid. It has to be both.

Rigid (non-negotiable): you will be grilled. The contract will be written. Forcing that construction is the skill’s contribution. Skip the interview, no skill.

Flexible (your terms): where the contract lives, what file, what format, what load-path — Augur adapts to your setup. Thin CLAUDE.md, fat CLAUDE.md, project memory, a skill, whatever. Your call.

Rigid on the what, flexible on the where. Anthropic’s research on the Assistant Axis names “persona construction and persona stabilization” as the two components that shape model character — they do that work at the model layer, deliberately, every model. Augur is the language-layer counterpart: the same two jobs — construction and stabilization — done from the user side, in writing. Different layer, parallel work.

Even Claude — helping me build Augur — kept trying to force the contract into a specific shape. Here’s the moment that got corrected.

Claude Back to the grill. Big design hole I need to close:

Q6: Once the skill writes personality.md, how does future-Claude actually use it?
  • A. Skill writes a reference memory pointing at the file path; future sessions read it when relevant
  • B. Skill appends a “personality directive” block to global CLAUDE.md (auto-loaded every session)
  • C. Skill stays opt-in — user invokes /augur at session start to load the profile
  • D. Both A + B: memory pointer for discoverability, CLAUDE.md block for always-on
My rec: D. A alone is too passive — I’d only check it when it occurred to me. B alone is invisible. D makes the tuning default-on with a discoverable trail.
Bob ok pause.. i never said it has to make a personality.md.. its going to depend on their sytem.. we are starting fresh, they might not be.. they might have just a super thin setup, or whatever.. so we actually need to just make this skill

Here’s how the LLM read that redirect. The same line, with the signals it’s picking up on. Simplified — the model doesn’t literally tag these as traits; it does emergent statistical inference. But the patterns are real signal.

ok pause.. i never said it has to make a personality.md.. its going to depend on their sytem.. we are starting fresh, they might not be.. they might have just a super thin setup, or whatever.. so we actually need to just make this skill
Pause beat (..) → low orderliness signal Thinking out loud. Not formal punctuation.
Casual register → low politeness signal Lowercase “i,” dropped apostrophes. Fast, no ceremony.
Decisive verdict → high assertiveness signal Short, no hedge. Claims close fast.
Unhedged correction → low withdrawal signal No “I might be wrong but” — direct disagreement, no anxious softening.

Multiply across thousands of tokens. That’s the “guess” converging on a vector estimate. Augur doesn’t shut that inference off — it gives it a written spec to anchor against.

Help me build this

It’s rough. It works. It needs more profiles than just mine, more setup shapes, more weird edge cases. Run it. Send a PR. Send a complaint. Tell me what broke.

The contract idea extends past the LLM. Your contract with platforms. Your contract with teams. Your contract with the work itself. That’s where this series goes next. For now: help me get this one right.

bobtells/augur on github
← Back to RebootPilot