CC / Codex / Hermes log #12: this week's takeaways came from thinking through how to elegantly work with Fable and /loops without killing my usage:
1. Writing great /goal prompts with /supergoal
>> Problem: I've had enough reps to feel confident in writing solid implementation plans, but I'm still building the muscle of writing great /goal prompts.
>> Solve: I've started having Fable run @robertcourson's /supergoal skill after my plans are written. Fable + /supergoal takes my plan doc, builds the execution packet around it (e.g., repo recon, memory preload, risk scan, phase specs, state files, verification commands, recovery rules, self-critique, and preflight), and then produces a great /goal prompt with optimized scaffolding. I can then feel confident giving that prompt to 5.5 / Opus / Sonnet for execution.
>> Link: https://t.co/RrfVng22ka
2. PR reviews with "no-mistakes"
>> Problem: I can have a coding agent run a PR review skill, but even Fable misses things. Skipped checks, stale docs, a PR description that no longer matches current state, etc.
>> Solve: no-mistakes, built by @kunchenguid, provides this gate. It runs through a fixed sequence: intent, rebase, review, tests, docs, lint, push, PR, CI. Safe fixes can land inside the gate. Intent-sensitive findings come back to me. no-mistakes only opens or updates the PR after the branch passes the local gate.
>> Link: https://t.co/Yhk10pLmF9
3. Closing out work with /agent-retro and /doc-audit
>> Problem: I pair with agents to do most of my work across multiple sessions. The lessons end up buried in transcripts, and if I'm in a repo, remaining docs can describe a state that no longer exists. The next agent inherits stale context.
>>Solve: I end most large pieces of work with /agent-retro and then /doc-audit. /agent-retro (Gianni Massi) mines the sessions for what did / didn't work and a follow-up proposes skill updates. /doc-audit fans out read-only subagents to find stale claims and then updates them after my approval.
>>Link: https://t.co/yldUy7FpeR
I've loved sending people to @TownAI. I spend a lot of time helping people get value from AI. Most AI tools still ask too much of the user before they become useful. Too much setup, too much context gathering, and too much understanding of how the system works.
I like thinking and working through all this: understanding agent harnesses, figuring out what context belongs where, teaching people when to use something like the Snowflake MCP server and how to prompt an agent to use it, building and sharing Skills, wiring up MCPs and CLI tools, explaining when to use scheduled jobs or subagents, configuring your Hermes agent, etc. This is workable if your job is already to think this way, but it is a lot to ask of everyone else.
Town starts from the other direction. It learns enough about you and your team's actual context to find useful work, suggest routines, pull from the right sources, draft in your voice, and leave you with review instead of setup.
Example: my mom (not technical at all!). After she set up her Town agent, it saw that she was remodeling her house and had contractor quotes piling up in her inbox. It created a quote tracker, checks for new quotes each day, and gives her a running summary of cost, scope, open questions, what to consider next, and reply drafts.
Unprompted, her Town agent took a mess of information and not only organized everything with optimal context, but made it super simple for her to action on it all (and actually actioned for her).
She didn't need to know how to prompt, configure a scheduled job, set up an MCP server, or understand an agent harness.
The best agents for most people / companies will give them the leverage of an agent operator without requiring them to become one. They will learn enough about your context to find the work, do the parts they can do well, and leave you with the parts that actually need your judgment.
Recommend trying Town out!
Today, we’re launching @TownAI: the AI assistant that learns you.
We’re coming out of beta with a $55M Series A led by @ARampell at @a16z, with participation from @KirstenGreen at @forerunnervc and continued support from @firstround, @altcap, and @conviction.
Right now, getting real value from AI means prompting, configuring, building workflows, managing agents.
We think that’s backwards.
The future of AI is a companion that already knows you and how you work. Town connects across your inbox, calendar, Slack, docs, messages, and workflows to understand what you need, then starts doing the work with you.
Drafting. Scheduling. Project tracking. Follow-ups. Context gathering. Multi-step tasks. And it only acts when you say so.
All adapting to your voice, priorities, routines, and relationships over time.
Your Townie is the AI assistant you actually need.
CC / Codex / Hermes log 9: how I'm using my agents this week...
1. Giving agents real-time X search via xurl
2. Asking an agent to ask agents
3. Printing CLIs for any service with @ppressdev
3. Printing Press: agent-native CLIs from any service
@mvanhorn + @trevin shipped a CLI factory that prints local, SQLite-backed CLIs from any API spec.
Wanted my agent to access my Strava data. Typed /printing-press strava in CC. After OAuth: efficient CLI.
Now I ask "summarize my runs the last 30 days, compare to prior 30, flag trends" and it pulls, computes, writes the summary into my daily Obsidian note.
Every service I touch is one prompt away from being agent-readable.
Better default discovery, better default verb, better default tool wrapper.
2. Asking an agent to ask agents
@VictorTaelin's frame: don't ask Codex to do stuff. Ask Codex to ask Codex.
For both eng and non-eng tasks, dispatch a few subagents, have them judge each other, hand me the best. Saves time even when it costs tokens.
Real example: told CC to spin up 4 subagents to draft outreach copy for a close-lost re-engagement play.
2 came back generic. 2 opened with the original close-lost reason from Salesforce.
Orchestrator picked the winner. Shipped that.
Warning: not token efficient.
3. /goal for end-to-end execution
Before /goal: hand CC a plan, get back a confident done, find broken output.
Now every agent has a /goal primitive. Tell it what done looks like, it works and checks until it gets there.
Vague criteria -> confident wrong answer.
Example: my agent built a feature for my iOS prayer app, tested it, opened the simulator, walked all user flows, and iterated until passing every test from the original /goal prompt.
Built a skill (plan-to-goal) that turns implementation plans into tight goal prompts.
CC / Codex / Hermes log 8. Three setups working really well right now:
1. @Plaid CLI as a personal finance agent substrate
2. Hermes EOD scheduled jobs connected to my gbrain
3. /goal for end-to-end agent verification
Breaking each down:
@Plaid 2. Hermes EOD scheduled jobs
EOD, my Hermes agent sweeps meeting notes, Slack, email, daily logs, CC/Codex/Hermes sessions, GitHub, and todos.
Returns: what shipped, what is open, what I am waiting on, tomorrow first move.
Needs a solid second brain. When right: next-level.
@Plaid The CLI lets the agent drill from balances into per-security holdings, cost basis, gain/loss, and transaction context.
Automatically catches concentration risk, expense drift, and tax-loss-harvest opportunities.
@Plaid 1. @Plaid CLI as a finance agent substrate
Plaid ships a CLI built for agents. I run it for finance Skills (portfolio-optimizer, finviser-alpha, weekly-finance-snapshot).
Knows me via my second brain, has skills wired to my goals, sees 10 institutions in one view.