Tari Ibaba

Claude Code’s Ultracode helps you finish large coding tasks faster, avoid context overload, and catch bugs earlier.

Instead of making one agent do everything, it creates an orchestration script that splits the work among smaller agents, runs tasks in parallel, and checks the results.

Let’s look at the key features that make it so useful for every developer.

1. Dynamic multi-agent orchestration: Keep context clean and improve code quality

When Claude handles a large task alone, its context fills up with code, logs, and earlier decisions. This can make it harder to focus.

Ultracode creates a script that splits the work among smaller agents. Each agent starts with a fresh context window and focuses on one part of the task.

This helps developers make large changes without forcing one agent to remember everything.

Example: Moving from JavaScript to TypeScript

Say you have an app with 300 JavaScript files. You could enter:

Plain textCopied!

ultracode: Migrate this JavaScript app to TypeScript. Use parallel agents and fix all type errors.

Ultracode could give different agents instructions like these:

Searcher agent

Plain textCopied!

Find JavaScript modules and their dependencies.

Implementation agent

Plain textCopied!

Convert the product catalog to TypeScript.

Testing agent

Plain textCopied!

Run type checks and report errors.

Here’s a simplified version of the orchestration script that could coordinate these agents:

Plain textCopied!

import asyncio

async def main():
    # Step 1: Understand the project
    deps = await run_agent("searcher", "Find dependencies")

    # Step 2: Convert two modules at the same time
    await asyncio.gather(
        run_agent("coder", "Convert products to TypeScript", deps),
        run_agent("coder", "Convert checkout to TypeScript", deps)
    )

    # Step 3: Check for errors
    await run_agent("tester", "Check TypeScript errors")

asyncio.run(main())

Here, run_agent() stands for the code that starts a Claude sub-agent. The script first finds dependencies, then converts independent modules at the same time. Once those changes finish, it runs type checks.

Each agent gets the information it needs, while the script handles the order of work. You can manage large changes without keeping every step inside one conversation.

2. Smart state management: Save tokens and keep context focused

In a normal Claude Code session, every command output, error message, and debugging step can take up space in the conversation.

Ultracode keeps much of this information in its orchestration script. The script tracks progress and collects results, then sends the main agent a short summary.

This helps developers save tokens in the main conversation and keep more context space for important decisions.

Example: Checking 200 API routes for security issues

You could ask:

Plain textCopied!

ultracode: Check 200 API routes for missing authorization checks. Verify the findings.

An agent might return:

JSONCopied!

{

  "file": "src/routes/orders.ts",

  "line": 42,

  "issue": "Missing authorization check",

  "severity": "high"

}

After collecting and checking the findings, the main agent might receive:

Plain textCopied!

Security Audit Summary

Routes checked: 200

Possible issues: 12

Confirmed issues: 8

False alarms: 4

Instead of reading hundreds of logs, Claude gets the information it needs.

This can save tokens by cutting unnecessary context, but running more agents can still increase the total tokens used.

3. Massive parallelism: Finish large coding tasks faster

Ultracode can run up to 16 agents at once by default and coordinate up to 1,000 agents during a run.

Instead of making one agent read files, change code, and run tests one after another, it lets multiple agents work at the same time.

The main script keeps track of which tasks depend on others and makes sure they run in the right order.

This means we can spend less time waiting for large code changes, migrations, and tests to finish.

4. Adversarial review loops: Find bugs earlier and spend less time fixing them

Ultracode can split coding work into three stages: Understand the code → Make changes → Check the results.

Different agents handle each stage. Some agents write code, while others try to find bugs, test edge cases, and challenge the changes.

When a review agent finds a problem, the script sends it back for fixing and checks the result again.

This helps you catch mistakes earlier, spend less time debugging, and feel more confident about their code before committing it.

5. Saved workflows: Stop repeating tasks and save time

Ultracode lets you save useful scripts with /workflows and turn them into custom slash commands.

Instead of explaining the same task every time, you can run a saved workflow.

Teams can also share and update these workflows so everyone follows the same process.

This cuts repetitive work, saves setup time, and makes regular coding tasks easier to manage.

Ultracode helps us handle large coding tasks without putting everything on one AI agent.

It keeps context cleaner, runs tasks faster, cuts unnecessary token use, catches bugs earlier, and makes repeated work easier.

The biggest benefit isn’t just having more AI agents. It’s getting those agents to work together so developers can spend less time managing tasks and more time building software.

This is one of the most powerful dev features recently released for Claude Code and the overall Claude ecosystem.

Claude Code Projects helps you manage all your development work in one place without constantly switching between chats or repeating instructions.

It lets you work on several tasks at once without mixing things up using Threads — and it intelligently remembers context across all your projects — so you don’t have to start from scratch every time.

Demo: Claude Code Projects automatically creates several threads for every single feature and sub-task to be completed:

We can also let Claude handle long-running tasks while we focus on other work — so you time managing AI sessions and more time building software.

1. Run multiple tasks at once with parallel threads

Normally when we use AI coding tools, we either handle tasks one after another or open separate chats to work on different things.

Claude Code Projects gives us parallel threads so we can run several tasks at the same time within one project.

Let’s say you’re building a SaaS app. You can ask Claude to build an authentication feature in one thread. In another thread it can write unit tests while a third thread handles a payment bug.

Each thread focuses on its own task without mixing up instructions from the others. This means we can get more work done at once without having to manage several separate chats ourselves.

2. Keep project context across threads

One annoying thing about using AI coding tools is having to explain your project over and over again whenever you start a new chat.

You might need to remind Claude that you’re using Next.js with TypeScript and PostgreSQL. You may also need to explain how you’ve structured your code.

With Claude Code Projects, you can keep your repositories and documents alongside your coding rules and project memory.

When you start a new thread, Claude can use this shared context to understand your project.

So instead of spending time explaining your tech stack or coding style again, you can jump straight into the task. This also helps Claude follow the same patterns across different parts of your codebase.

3. Let Claude work in the background

Some development tasks take a long time. Things like refactoring a large codebase or migrating an app can involve several steps.

Claude Code Projects lets you run tasks in the background even when you close your laptop or step away.

Let’s say you want to move a JavaScript project to TypeScript. You can ask Claude to update the files and fix type errors before running tests while you focus on something else.

You can come back later to check the progress or review the results.

This means you don’t have to sit around waiting for Claude to finish every step before moving on to other work.

4. Manage pull requests and code reviews more easily

Writing code is just one part of building software. We also need to review changes and run tests to make sure everything works before merging.

Claude Code Projects makes this easier by working with Git-based workflows.

Claude can check code changes and review diffs. It can also create pull requests and help fix failing CI checks.

Demo: Claude lets you automatically review a PR for a set of changes made:

It can use your project’s coding rules to spot issues like missing tests or poor error handling. It can also flag code that doesn’t follow your team’s style.

This helps us catch common issues earlier and spend less time on repetitive review tasks. We can then focus more on important things like security and architecture.

5. Keep files and outputs in one library

When we work on a project, we create more than just code. We also have documents and diagrams as well as configuration files and reports.

Claude Code Projects gives us a central Library where we can keep uploaded files and outputs Claude creates.

Let’s say Claude creates an architecture document while you’re planning a feature. You can keep that document in the Library and use it later when building or testing the feature.

This makes it easier to find important files and reuse previous work. It also helps us keep everything organized instead of searching through old chats.

Claude Code Projects makes it easier to handle bigger development tasks without constantly managing separate chats or repeating instructions. With more of the routine work handled by Claude, we can focus on building features and solving problems that matter.

If you’re paying for Claude Pro, Max, or Ultra — you need to run claude update right now.

Anthropic just fixed a major bug that was wasting thousands of tokens during multi-agent parallel coding.

Every background subagent was silently burning your tokens every 30 seconds by re-reading the entire conversation history just to report its progress status.

The fix cuts down massively on the token costs spent on the status polling — and gives you more usage out of your limits to spend on actual coding.

Now Claude Code now uses a much more lightweight approach.

1. Claude Code was wasting tokens on a single line of text

When you ran a background agent in Claude Code’s command-line interface (CLI), it showed a short status message every 30 seconds.

You might see something like “Analyzing dependencies” or “Running tests.”

To generate that one line of text Claude Code would read the agent’s entire conversation history from beginning to end.

And it did this every 30 seconds.

Imagine running a coding task with 100,000 tokens of conversation history. Claude could keep processing that huge amount of text just to tell you what the agent was doing.

The longer your session ran the more tokens you wasted without getting any extra coding work done.

2. Status update costs just dropped by 99%

Anthropic fixed the problem by changing how Claude Code generates status updates.

Instead of reading the full conversation history it now uses short notes and a smaller model called Haiku.

This change cuts the cost of each background status update by 99%.

That’s a massive improvement for those of us who run long coding sessions or keep several background agents working at once.

Your agents no longer need to process thousands of tokens just to report their progress.

This means less wasted usage and more tokens available for actual coding tasks. And you don’t need to change how you work to benefit from the fix.

3. The problem only affected Claude Code CLI users

Not everyone using Claude Code had this problem.

The repeated status updates were part of the CLI experience.

If you used Claude Code through the desktop app you weren’t affected by this specific issue. The desktop app doesn’t use the same terminal status-line polling system.

Those of us who spent hours running background agents in the terminal were more likely to waste tokens.

Running several agents at once could make the problem even worse.

4. Prompt caching made the problem worse

Claude Code uses prompt caching to avoid processing the same information from scratch every time.

But before the fix caching didn’t always prevent unnecessary token usage.

Every background status update could trigger another large context read.

If the cached context had expired or Claude couldn’t reuse it then the system had to process that information again at a higher cost.

Imagine paying to process thousands of tokens just to display “Checking files.”

By switching to short notes Anthropic removed much of this unnecessary overhead.

5. Developers are asking Anthropic for refunds

The fix also raised questions about the tokens people had already lost.

Some Claude Code users were frustrated to learn that background status updates had been consuming their usage limits.

For Pro and Max subscribers this meant hitting quotas sooner than necessary. For API users it raised concerns about money spent on unnecessary requests.

Some developers have called for Anthropic to restore affected quotas or offer credits for wasted usage.

Nobody wants to spend their limited AI usage on a status message that could have cost almost nothing.

There’s still no confirmed broad refund program tied to this issue.

Anthropic’s fix means we can spend more of our Claude Code usage on actual coding instead of unnecessary background updates. But it also raises a fair question about how much of our previous usage went toward work we never needed.

These five tips will help you get more coding done with fewer tokens.

You’ll spend less on API costs and hit usage limits less often.

1. Keep context lean and clear

The longer you chat with your AI coding agent the more context it has to keep track of.

Old messages and debugging attempts can pile up quickly. Most of that stuff becomes useless once you move on to something else.

In Claude Code you can clean things up with:

JavaScriptCopied!

/compact

This tells Claude to summarize your conversation and keep the important details.

You can also tell it what to keep:

Plain textCopied!

/compact Keep the key decisions and remaining tasks

Don’t wait until your context window is almost full. Compact after fixing a tricky bug or finishing a big task.

If you’re starting something completely new use /clear instead.

2. Take advantage of multi-phase planning

You don’t need your most expensive AI model for every task.

Planning a complex feature takes a lot more brainpower than writing code from a clear set of instructions. You can save money by using different models for these tasks.

Start with a powerful model like Claude Opus to think through the problem and write a solid plan.

Then switch to a cheaper model like Sonnet or Haiku to write the code.

In Claude Code you can switch models with:

JavaScriptCopied!

/model

You can even do this:

JavaScriptCopied!

/model opusplan

This uses Opus for planning and Sonnet for execution if your setup supports it.

You won’t always use fewer tokens this way. But you can spend a lot less money on them.

3. Don’t waste coding context asking questions

You can waste a lot of context by asking your coding agent questions that have nothing to do with your current task.

Say you’re building a login system and want to know how JWT works.

You ask Claude for an explanation and follow up with a few more questions. All those messages now take up space in your coding context.

Claude Code’s /btw command helps you avoid this:

Plain textCopied!

/btw How does JWT authentication work?

This lets you ask quick questions without adding them to your main conversation.

For longer discussions you can use:

Plain textCopied!

/export

Copy your conversation and paste the relevant parts into ChatGPT or Gemini for free continue chatting there.

So you end up only using your paid coding tokens for actual coding.

Just make sure you don’t share private code or secrets.

4. Ignore files the right way

Your AI doesn’t need to read every file in your project.

Folders like node_modules/ and dist/ can eat up a huge amount of context for no good reason.

You might try creating a .claudeignore file to stop this. But Claude Code doesn’t actually support .claudeignore by default.

Instead you can block files in .claude/settings.json:

JSONCopied!

{

  "permissions": {

    "deny": [

      "Read(.env*)",

      "Read(config/secrets/**)"

    ]

  }

}

You can also tell Claude to avoid unnecessary folders in your project instructions.

For more control you can use hooks to stop Claude from reading certain files.

5. Use AGENTS.md like a pro

You waste tokens every time you repeat the same project instructions to your AI.

You might have to remind it to use pnpm instead of npm or tell it not to touch generated files. You might also need to explain where certain files live.

You can put all these instructions in AGENTS.md so your AI can find them when it needs them.

Here’s a simple example:

Plain textCopied!

# Project Instructions

## Stack

- Next.js

- TypeScript

- PostgreSQL

## Commands

- Test: pnpm test

- Build: pnpm build

## Rules

- Follow existing code patterns.

- Don't edit generated files.

- Write tests for new features.

Keep this file short and focused on the things your AI needs to know most often.

If you have long docs just link to them and tell your AI to read them only when it needs them.

This helps you avoid wasting tokens on information that has nothing to do with your current task.

These habits help you spend less on AI while getting more coding done.

This is one of the most powerful AI coding frameworks I’ve seen in a long time.

P-Stack massively boosts your development speed and the reliability of all the code Claude Code puts out by making it follow top-tier software engineering practices.

It uses a powerful “Poteto Mode” to route tasks through clear workflows and built-in engineering principles to guide how Claude Code solves problems.

You avoid unnecessary code and fix problems at their root — and spend much less time writing detailed prompts and checking broken changes.

1. Smart task routing with Poteto mode

One of P-Stack’s best features is poteto-mode. It looks at your task and picks a clear workflow.

Instead of letting Claude Code figure out every step on its own, P-Stack gives it playbooks for fixing bugs and building features based on standard engineering practices. It also covers refactoring and performance optimization.

Example: Ask Claude Code to speed up a slow API. Poteto-mode can guide it to measure the current speed and find the bottleneck. It then makes a fix and runs benchmarks to check the results.

You don’t need long prompts explaining every step. P-Stack helps Claude Code follow a more predictable process.

2. High-quality code generation powered by built-in engineering principles

We’ve all seen AI turn a simple fix into a complicated solution with extra files and dependencies.

P-Stack helps prevent this through engineering principles in SKILL.md files.

Some key principles include:

• Laziness Protocol: Make the smallest change that solves the problem.
• Subtract Before You Add: Remove unused code before adding new things.
• Attack the Premise: Question whether the requested solution is actually right.
• Minimize Reader Load: Keep code easy to read.
• Model the Domain: Structure code around how the business works.

Example: You ask Claude Code to add Redis because an API is slow. Instead of adding Redis, it might discover that fixing one database query solves the problem.

The goal is to write less code and make that code better.

3. Investigation skills: how and why

AI agents sometimes rush to fix bugs without understanding what’s causing them — that’s why P-Stack gives us two investigation skills:

The how skill helps Claude Code understand and reproduce an issue through tests or scripts.

The why skill traces the code to find the root cause.

Example: Your checkout system creates duplicate payments. Instead of disabling the checkout button, Claude Code can trace the requests and discover that the backend doesn’t handle repeated requests safely.

This helps us fix the real problem instead of patching its symptoms.

4. Strict verification: Prove it works

We’ve all seen an AI agent say everything is done when the feature doesn’t actually work.

P-Stack pushes Claude Code to go beyond passing tests. It encourages checking real application behavior through runtime tests and logs.

Example: After building a signup feature, Claude Code should try creating an account and check that the database saved the user. It should also confirm that the user can log in.

This gives us better proof that a change works and reduces the time we spend checking broken AI-generated code.

5. Multi-agent and multi-model orchestration

P-Stack lets us split work between specialized agents:

• Implementation agents write code and tests.
• Architect/Judgment agents evaluate design decisions.
• Review agents check for bugs and security issues.

We can also use different AI models based on what each does best.

Example: When building a subscription system, one agent can plan the payment flow while others build the backend and frontend. Review agents can then check the changes.

Using separate Git worktrees or branches helps us run tasks in parallel without agents constantly changing the same files.

P-Stack isn’t just about making Claude Code write more code. It’s about helping us build better software with less manual work and fewer AI mistakes.

Google just released an powerful new set of Skills and Claude Code extensions.

They are based on this incredible concept called EGM — an innovative way of working with coding agents that thousands of engineers at Google use everyday.

The new Elephant-Goldfish Model (EGM) improves the quality of your software by using an “Elephant” and a “Goldfish” to catch every single design issue before they turn into code.

The Elephant plans the features and then the Goldfishes meticulously challenge and review the plans.

This helps us avoid costly rewrites and catch mistakes much earlier, and it also gives a clearer way of working with AI agents.

1. The Elephant: Think first, code later

The Elephant acts like an experienced software architect who understands your project and what you’re trying to build.

Instead of jumping straight into coding it follows a no-code-first approach. It asks questions and challenges your ideas. It also looks for potential problems and writes a design document like concepts_brief.md.

Example: Say you want to build a payment system. Rather than immediately writing APIs the Elephant first asks what happens when a payment fails or someone pays twice. It also considers what happens if the database goes down.

This helps you catch design problems early and avoid rewriting large parts of your application later.

2. The Goldfish: AI agents that challenge your design

Once the Elephant finishes the design EGM brings in independent AI reviewers called Goldfish.

These agents know nothing about earlier design conversations. They only see the design document and relevant code so they can question things the Elephant might have missed.

Each Goldfish takes on a different role like Design Critic or Tech Lead. Others act as a Naive Reader or Codebase Auditor.

Example: Say you’re building a login system. One Goldfish might notice missing security checks while another might point out that your password-reset process isn’t clearly explained.

This gives you fresh opinions instead of relying on the same AI that created the design to find its own mistakes.

3. Automated code-to-design drift detection

We all know how quickly documentation becomes outdated. You change your code or add features but forget to update the docs.

EGM gives us /egm-drift-report. This skill compares your design documents with your current code and flags possible differences.

Example: Your design document says your application uses REST APIs but you’ve moved some features to GraphQL. EGM can flag that difference so you can update the docs or review the code.

This helps you keep your documentation in sync with your code and gives future AI agents more accurate project information.

4. Spec-driven development: A clear way to work with AI

Instead of jumping between random prompts EGM gives us a clear process for planning and reviewing features using simple commands, like:

• /egm-brainstorm — Explore ideas and requirements.
• /egm-draft — Turn ideas into a detailed design.
• /egm-review — Let independent AI agents check the design.

You can store these documents in your repository under docs/designs/.

Example: Say you want to add real-time notifications to your e-commerce app. You start with /egm-brainstorm to compare WebSockets and polling. Next you use /egm-draft to write the design. Then you run /egm-review to catch missing details before coding.

This lets you spend less time fixing AI-generated code and more time reviewing plans and making technical decisions.

5. Recursive codebase bootstrapping

If you’ve ever joined a project with thousands of files and little documentation then you know how hard it can be to understand.

EGM gives us /egm-bootstrap. This skill explores your codebase and creates README.md files across folders to explain what each part does and how everything connects.

Example: In a large e-commerce app it can create documentation explaining how your authentication and inventory modules work and how they connect with payment and order processing.

This helps you and your AI agents understand unfamiliar projects faster without digging through every file.

Google’s Elephant-Goldfish Model helps us move beyond writing code faster by making it easier to plan better and catch mistakes early. The goal is simple: spend less time fixing avoidable problems and more time building the right thing.