1 Overview
Six months ago, the best practices for Claude Code looked completely different. The shift isn't because models got smarter — it's because the community has fundamentally changed how people use Claude Code. Simon Scrapes walks through the three biggest paradigm shifts: rethinking memory with open-source plugins, leveling up planning with effort levels and Ultra Code, and automating repetitive workflows so Claude runs on its own and only pulls you in at decision points.
2 The Memory Problem Out of the Box
Out of the box, Claude Code's memory is fundamentally limited. It ships with a single claude.md file that you write and maintain by hand — and that hasn't changed. The built-in memory.md file is supposed to capture information in the background and act as an index, but in practice it captures almost nothing. After months of use, Simon's had only 5-10 notes in it — rendering it completely useless.
This creates two critical problems for users:
- You become the memory — You're the one re-pasting your brand voice, customer details, and decisions from 3 months ago because Claude isn't holding any of it
- Fragile recall — If you can't remember the exact words from a session 3-8 months ago, that information is effectively gone forever. Keyword-based search through full session history is dense, token-heavy, and unreliable
3 The Three Functions of a Good Memory System
Simon breaks memory down into three distinct functions, each of which Claude Code handles poorly out of the box:
- Storage — Where information is kept and how the system decides what's worth keeping. Claude Code doesn't capture full transcripts and compresses conversations as you continue working. A proper system captures transcripts as you work and decides what's worth keeping in the background
- Short-term injection — Pulling the most relevant context into the conversation as you work. Claude Code only injects the static
claude.mdfile — a file you keep forgetting to update. A good system pulls relevant context dynamically so the model works with what matters right now - Long-term recall — Finding past information without needing exact keywords. This is the weakest point: Claude Code relies on keyword search through dense session history. A good system stores information by meaning, not just by keyword — so you can ask "what did we decide about pricing for our agency clients?" six months later in plain English and it'll find it
4 Community Memory Solutions
The open-source community has already closed most of the memory gap — and it's far less technical than it sounds. These tools install as plugins or small frameworks on top of Claude Code, requiring no database setup from scratch.
MemArch
A two-line install that provides storage, injection, and recall out of the box:
/plugin marketplace add memarchinstall memarch- Restart Claude Code — memory is now being stored and working
MemArch builds on top of Claude's existing memory functions, so it future-proofs for any updates Anthropic eventually makes to their memory system.
GBrain (by Gary Tan)
Designed for multi-user or larger team scenarios. Provides cited recall — when it retrieves a memory, it tells you where it came from. Supports three levels of recall depth.
Hermes
An open-source agent framework with strong memory injection of files, keeping the most important recent context readily available.
5 Building a Custom Memory Stack
For his own agentic operating system, Simon cherry-picks the best features from each framework:
- From GBrain — Cited recall for multiple users with three levels of recall depth
- From Hermes — Better injection of files for the most important recent context
- From MemArch — Storage and background capture functionality
The result is a custom system for multiple users with cited recall, three levels of depth, and better context injection. The key principle: a proper memory system captures the right things, keeps relevant bits in local injectable memory, and lets you find anything later by just describing it.
6 Shift #2 — Planning & Effort Levels
The old planning method was either running one long execution session or using plan mode. As people started using Claude Code seriously, they realized the biggest limitation is context management — how you save the plan and inject the right information at the right time. This is fundamentally the same problem as memory: storing and recalling the right information.
Community Approach: Agentic Operating Systems
The community (including Simon) solved this by architecting file structures for specific context — brand voice, positioning, ongoing projects — then adding dashboards to visualize those files. These became known as "Agentic Operating Systems" or "Agentic OS."
Anthropic's Approach: /effort
Anthropic took a different route to solve the same problem. Their answer: for more complex tasks, you need better thinking up front — more tokens allocated to reasoning before acting. The /effort command lets you set how hard Claude reasons before it acts:
- Low — Quick jobs that don't require deep thinking
- Auto (default) — Claude auto-detects complexity. Good at identifying low-to-medium tasks, but poor at identifying when high/max/ultra is needed
- High / Max — Complex planning tasks requiring more reasoning tokens
- Ultra Code — The extreme level: builds a dynamic workflow with multiple agents for a specific task
7 Ultra Code — Multi-Agent Workflows
Even with a great plan, Claude typically tackled everything in one session with a single agent. What if you wanted a team? You had to tell it explicitly. Ultra Code changes this by automatically building dynamic workflows for specific tasks.
When you invoke Ultra Code:
- You enter your prompt — the task you're assigning
- Claude writes its own plan — including a bespoke workflow tailored to the task
- Spins up a team of agents — each agent gets a clean slate with a very specific set of context and a single job
- Cross-checks their work — multiple agents verify each other's output using adversarial review patterns
- Hands back a finished answer — once all stages complete
Anthropic documents six common workflow patterns that Ultra Code can spin out — but it can also create completely bespoke approaches tailored to your specific problem. The key breakthrough: it takes the human thinking element out of planning the workflow entirely.
8 Ultra Code Demo — Building Newsletter Skills
Simon demonstrates building a set of skills that scout his inbox every morning for AI newsletters. The prompt:
What Ultra Code does with this fairly complex prompt:
- Scouts conventions first — reads the existing meta skill-creator skill to understand how skills should be structured
- Understands context — reads the ICP (ideal customer profile) and discovers the Gmail MCP connection
- Plans the architecture — decides on two reusable skills and a cron job:
- tool-gmail — gathers information from Gmail using the Google MCP
- Strategic Newsletter Digest (STR) — the "curation brain" that pulls AI newsletters, breaks them into stories, scores each against the audience, ranks them, and writes a morning digest
- Asks clarifying questions — How should the digest be delivered? How to wire up the cron? These are the human decision points
- Spins up the workflow — visible in
/workflows:- Design stage → single agent designs the rubric
- Build stage → two parallel agents build each skill simultaneously
- Integration stage → merges and verifies
- Adversarial review → verifies against conventions
The entire process is observable: you can jump into any agent's specific conversation to see exactly what activity is happening at each stage.
9 Shift #3 — Stop Working, Start Describing
Everything so far has been about getting a single job done well — good context, a plan that survives, and a team that builds itself. But all of that still assumes you're sitting there kicking off individual tasks. The real shift is when you stop being the one who has to press go every time.
The question isn't "can Claude run on its own?" — it's which jobs can you actually walk away from? The honest answer: a specific kind of job.
- Good candidates for autonomy — Repetitive work with a clear finish line you can describe: inbox triage, drafting first versions of social posts, research tasks, daily summaries, monitoring checks
- Not ready for full autonomy — Tasks requiring judgment, important decisions, creative direction. You still want to be there for these
The trick isn't full autonomy — it's letting the repetitive grunt work run while keeping yourself on the decision points and quality control.
10 /goal, /routines, and /loop
Two features inside Claude Code make autonomous execution work — and they're strongest when used together:
/goal — Set a Completion Condition
- Define a checkable finish line (e.g., "each long-form post has been transformed into three repurposed content pieces")
- After each turn, a smaller fast model (like Haiku) checks whether completion conditions are met
- Claude Code keeps going on its own instead of stopping and handing back to you
- Only returns when conditions are met, or when genuinely stuck
- This is the loop condition from the workflow patterns — it drives itself to completion
/routines (or /schedule)
- Creates scheduled Claude agents that execute on their own cadence
- Can also use
/loopfor simpler recurring tasks running on your local machine (up to 3 days) - Set an interval and a prompt — Claude handles the rest
Why They're Powerful Together
You set a recurring task (routine) with completion conditions (goal) so it doesn't stop midway through. The routine triggers Claude on a schedule, and the goal ensures each run completes fully before finishing. This creates set-and-forget infrastructure for daily tasks.
11 Newsletter Digest Demo — Putting It All Together
Simon continues the earlier demo, now using the skills created by Ultra Code with /goal:
The prompt: "Run the STR newsletter digest on all emails from the last 72 hours and return content ideas."
Completion conditions:
- All emails checked
- A list of content ideas (or "none" if no appropriate newsletters found)
- For the three best items, draft a short LinkedIn post and a thread using marketing copywriting and content repurposing skills
What happens:
- Claude acknowledges the goal, widens search from 48 to 72 hours as specified
- Scans the inbox — finds only one genuine newsletter (filters out marketing emails)
- Scores it: 16/22.5 on the metrics rubric
- Since 3 ideas are needed but only 1 email qualifies, derives 2 additional angles from that single email
- Loads voice and content skills, then drafts LinkedIn posts and threads
- Reports "Goal complete" — repeats all criteria as confirmation
- Even recommends: "Add these email senders to your newsletter senders YAML" — making future runs more efficient by narrowing the inbox search
✦ Key Takeaways
🔑 Key Takeaways
- Claude Code's built-in memory is effectively useless — the
memory.mdfile captures almost nothing even after months of use, and keyword-based recall through session history is dense and unreliable - Good memory needs three functions — storage (capturing the right things automatically), short-term injection (pulling relevant context dynamically), and long-term recall (searching by meaning, not keywords)
- Community plugins fix the memory gap with minimal setup — MemArch installs in two lines, GBrain adds cited multi-user recall, and Hermes provides strong context injection
- The /effort command unlocks scaled reasoning — auto mode handles simple tasks well but you need to manually escalate to high/max/ultra for complex work
- Ultra Code creates bespoke multi-agent workflows — it plans the task, spins up specialized agents, cross-checks their work, and returns a finished answer without you designing the workflow
- Six workflow patterns power Ultra Code — including adversarial review, parallel builds, and staged design → build → integrate pipelines
- Not everything should be autonomous — the ideal use case is repetitive work with a clear, describable finish line; keep humans on judgment calls and creative decisions
- /goal sets checkable completion conditions — a smaller model verifies conditions after each turn, so Claude drives itself to completion rather than stopping prematurely
- /routines + /goal is the automation sweet spot — recurring schedule ensures the task fires on cadence, while goal conditions ensure each run completes fully
- Context management remains your responsibility — brand voice, customer details, and past decisions still need to be brought in; these three shifts make Claude better at using that context, not replacing it
- The agentic OS pattern emerged naturally — file structures for specific context (brand, positioning, projects) plus dashboards to visualize them evolved from the community solving the context management problem
🔗 Resources & Links
- MemArch Plugin — Memory architecture plugin for Claude Code (install via
/plugin marketplace add memarch) - Hermes Agent — Open-source agent framework with strong memory injection and context management
- Claude Code Documentation — Anthropic's official docs covering /effort, Ultra Code, /goal, and /routines