DISCLAIMER: free, opensource, runs locally, I use it daily, nobody is selling anything, there is no business, no service, nobody to pay or complain to. constant development. if you want it just take it.
https://github.com/AnEntrypoint/glootie-cc
Last month I posted about glootie, our in-house claude code plugin that turns the agent into a behavioral state machine instead of a text predictor. That post covered the first year - 2000 hours, 60 system prompt iterations, code execution, code search, hooks, AST analysis. The basics of how you stop an LLM from hallucinating and start making it do legwork.
This post covers what happened in the 28 days since. 201 commits. The agent behavior changed fundamentally. I want to explain what changed, why, and what it means if you're still fighting the same problems I was fighting a year ago.
tl;dr: the system prompt got restructured by studying the new WFGY 3.0 patterns. hooks went from reminders to brick walls. the agent can no longer use bash, write test files, skip code execution, declare itself done without proof, or stop a session with unfinished work. it can run on haiku and outperforms unconstrained opus, and when constraining opus it feels surreal in its accuracy.
THE PROBLEM WITH THE OLD SYSTEM PROMPT
THE NEW SYSTEM PROMPT: 7 CHARTERS
The rewrite compressed 33 sections into 7 numbered charters plus one constraints block. 4890 tokens down to 2723. I verified all 82 critical behavioral concepts survived the compression. Here's what each one does and why it matters for your daily coding:
Charter 1: PRD - before the agent touches anything, it writes a .prd file. not a todo list. a dependency graph. every item lists what it blocks and what blocks it. independent items get grouped into parallel execution waves and launched simultaneously as sub-agents. the stop hook physically blocks the session from ending while items remain. the .prd is frozen at creation - the only permitted mutation is removing finished items. no reorganizing, no adding items mid-flight, no scope creep.
Why this matters: without this, the agent picks a direction and starts coding. it forgets half the requirements, discovers them mid-implementation, and either bolts them on badly or ignores them. the .prd forces it to think through everything first - edge cases, failure paths, recovery paths, race conditions, boundary conditions, rollback paths - and then execute in dependency order.
Charter 2: Execution Environment - every hypothesis must be proven by execution before changing any file. the agent knows nothing until code execution proves it. bash is redirected to the code executor. find/glob/grep redirected to semantic code search. test frameworks redirected to real execution. mocking libraries redirected to real services.
Why this matters: this is the "stop thinking, start running code" charter. the agent's default behavior is to reason about what code should do, then write it. this charter forces it to run the code first, see what actually happens, then make changes based on evidence. the tool redirects are enforced by hooks so it physically cannot fall back to bash one-liners and grep.
Charter 3: Ground Truth - no mocks. no fakes. no stubs. no fixtures. no simulations. no test doubles. no canned responses. when discovering them in a codebase, delete them. unit testing is forbidden. real services or surface the blocker.
Why this matters: this is the most controversial rule and the one that saves the most wasted turns. I've watched the agent spend 15-20 turns writing mock services, setting up test fixtures, running unit tests that pass against fake data, and then shipping code that breaks against real services. all those turns were negative value - worse than doing nothing because they created false confidence. delete the mocks, hit the real service, find out what actually happens. if the service is down, tell me it's down. don't pretend.
Charter 4: System Architecture - every system the agent builds must be hot reloadable, uncrashable, self-recovering, with contained async and exposed debug hooks. recovery hierarchy: retry → isolate → restart component → supervisor restarts → parent supervisor → top level catches and recovers. systems run forever by architecture.
Why this matters: without this, the agent builds fragile systems that work in the demo and break in production. it doesn't add error boundaries unless asked. it doesn't think about what happens when a component fails. this charter makes resilience a default, not an afterthought.
Charter 5: Code Quality - reduce requirements (fewer requirements = less code), no duplication, no adjectives (never "optimized" or "advanced", facts only), convention over code, continuous modularization, buildless (ship source directly), dynamic (configuration drives behavior, not code conditionals), cleanup (remove everything unnecessary).
Why this matters: the "no adjectives" rule alone eliminates entire categories of hallucinated improvements. the agent loves to tell you it made something "more robust" or "optimized the performance." no. describe what the system does. never describe how good it is. this one rule changed the quality of commit messages, comments, and documentation overnight.
Charter 6: Gate Conditions - 14-point checklist that must ALL pass before any file modification. executed in code executor, every scenario tested, goal achieved with real output, hot reloadable, crash-proof, no mocks anywhere, cleanup complete, debug hooks exposed, under 200 lines per file, no duplicate code, no comments in code, no hardcoded values, ground truth only.
Why this matters: without explicit gates, the agent modifies files as soon as it has a theory about what might work. with gates, it has to prove the theory first. the "under 200 lines per file" gate alone prevents the agent from creating god objects. the "no comments" gate prevents it from writing novels inside your code.
Charter 7: Completion and Verification - the state machine sequence is search → plan → hypothesize → execute → measure → gate → emit → verify → complete. verification means executed system with witnessed working output. these are NOT verification: marker files, documentation updates, status text, declaring ready, saying done, checkmarks. only executed output the agent witnessed working is proof.
Why this matters: this is the "you're not done until I see it working" charter. the agent's strongest attractor is to declare victory. it will say "the implementation is complete" when it has written code but not run it. it will say "all tests pass" when it ran one test. this charter defines done as: witnessed execution, every scenario tested, goal achieved, real output, gate conditions passed, no remaining steps for user. the last 1% of work requires 99% of effort.
Constraints block - Never/Always lists replace 98 scattered prohibitions. never crash, never use fake data, never leave steps for user, never write test files, never summarize before done, never treat ready as done without execution. always execute in code executor, always delete mocks on discovery, always verify by witnessed execution, always complete fully with real data.
HOOKS WENT FROM REMINDERS TO BRICK WALLS
This is the change that made the biggest practical difference. Last time I posted, the hooks were mostly reminders - telling the LLM to continue, nudging it to push. They've been completely rebuilt.
Pre-tool-use hook: blocks Bash (redirects to code executor), blocks Write for markdown files (except claude.md and readme), blocks ALL search tools including glob and grep (redirects to semantic code search), blocks find, blocks test file creation. It checks file extensions, directory paths, framework configs. If you try to write a .test.js, a jest.config, anything in _tests/, any .snap/.stub/.mock/.fixture file - denied. Exit code 2.
The key insight: these are not suggestions. The hook returns exit code 2 with a deny decision. The LLM cannot use bash. It cannot write test files. It cannot skip the code executor. This is not prompt engineering hoping the model listens, this is a physical barrier. The behavioral prompt says what to do, the hooks enforce that it physically cannot do the wrong thing.
Session start hook: loads gm.md as the agent identity, injects semantic code search context (so the agent knows it has intent-based search available, not just regex), runs mcp-thorns for full codebase overview. The agent starts every session already knowing the codebase structure - file hierarchy, dependency graph, orphaned code, hub files, repetition patterns. No manual exploration turns needed.
Prompt submit hook: injects "always use gm sub agent for everything" on every single user message. Every message. Redundant by design. The training set has strong attractors toward default behavior. You need multiple reinforcement points or the model drifts back to its base personality within a few turns.
Stop hook (work tracking): reads the .prd file. If it has content, the session cannot end. The agent is physically prevented from saying "here's what you need to do next" and stopping. It has to finish the work or explain why it can't.
Stop hook (git): checks for uncommitted changes, unpushed commits, and whether the branch is behind upstream. If any of these are true, the session cannot end. No more "I've made the changes" without committing and pushing. The agent has to close the loop.
Both stop hooks work together. You can't stop with unfinished .prd items AND you can't stop with unpushed code. The agent must complete the work AND ship it.
SEMANTIC CODE SEARCH REPLACED ALL MANUAL EXPLORATION
Last time I talked about building a 4th version of codebase vector search. That's now stable and embedded in the session start hook. When a session starts, the agent gets told it has semantic search available and how to use it - describe intent, not syntax.
The pre-tool-use hook blocks glob, grep, and find, redirecting everything to semantic search. The agent can't partially search the codebase anymore. It can't grep for a function name and miss the 3 other files that implement the same concept with different names. Semantic search finds all of them because it understands intent.
"Find authentication validation" returns auth checks, guards, permission logic, middleware - however they're implemented, whatever they're named. This eliminated a whole category of turns where the agent would search for "auth" and miss "permission" and "access control" and "guard."
IF YOU'RE FIGHTING CLAUDE CODE RIGHT NOW
If your agent writes tests that don't test anything: charter 3 forbids unit testing, hook blocks test file creation
If your agent mocks services it should be calling: charter 3 deletes mocks on discovery, hook blocks mock/stub/fixture files
If your agent summarizes instead of working: charter 7 defines done as witnessed execution only, constraints block forbids summarizing before done
If your agent gives up and hands you instructions: charter 7 forbids handoffs, stop hook blocks session end with remaining work
If your agent uses bash for things that need proper execution: charter 2 redirects bash to code executor, hook physically blocks bash
If your agent searches half the codebase and misses the important files: charter 2 redirects to semantic search, hook blocks grep/glob/find
If your agent declares itself done when it hasn't verified: charter 7 requires witnessed working output, gate conditions must all pass
If your agent forgets to push: git stop hook blocks session end with unpushed commits
If your agent starts coding without planning: charter 1 requires .prd before any work, .prd is a dependency graph with parallel execution waves
If your agent drifts scope mid-implementation: .prd is frozen at creation, only removing finished items is permitted
These are all solved problems. Not by making the model smarter, but by making it impossible for the model to do the wrong thing and giving it better tools to do the right thing.
