Tari Ibaba

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.

This is such a powerful way to code with AI agents.

Gauntlet Loop is an innovative AI agent engineering method that uses separate agents to build and review work using well-defined standards and targets.

Instead of letting one agent create something and decide whether it’s good enough — the method uses independent critics to find problems and push for improvements.

This approach helps AI agents handle complex tasks through clear quality standards and repeated testing:

Don’t just ask AI to do great work. Build a system that makes it hard for poor work to pass as finished.

Here are the five crucial ideas behind it.

1. Separation of powers — The no self-grading rule

When you ask an AI agent to create something and judge its own work, it will often defend its choices and miss problems.

The Gauntlet Loop gives these jobs to different agents.

A Builder agent creates the work while a separate Critic agent reviews it with fresh context. The critic doesn’t see the builder’s earlier explanations. It checks the actual result against the requirements.

Example: A builder creates a login system and says it’s complete. The critic tests wrong passwords and expired sessions. It also checks whether unauthorized users can get in. This might reveal security problems the builder missed.

This way the agent doing the work doesn’t get to give itself a passing grade.

2. Quality bar externalization — Real examples beat vague prompts

Prompts like “build a professional dashboard” or “write clean code” sound good. But what exactly do “professional” and “clean” mean?

Without a clear target AI can easily settle for something average.

The Gauntlet Loop gives agents real examples or clear standards to work toward. These could be screenshots of existing products or tests the finished work must pass.

Example: An AI agent building a dashboard gets a screenshot of a polished SaaS product as its reference. The critic compares the new dashboard with that reference. It checks the layout and spacing as well as how the interface looks on mobile.

This gives the agent a clear picture of what good looks like instead of leaving it to guess.

3. Granular task decomposition — Break big jobs into smaller ones

When we give an AI agent a huge project to handle at once, things can quickly get messy. It might forget requirements or break one feature while fixing another.

The Gauntlet Loop uses a lead Orchestrator agent to break projects into smaller tasks that other agents can build and review separately.

Example: When building a video game the orchestrator splits the work into physics and lighting as well as player controls and UI. Different agents handle these parts while critics check each one before integration.

Breaking projects into smaller pieces makes it easier to catch problems early and keep the whole project on track.

4. Automated multi-hour iteration

Most of us use AI in a back-and-forth way. We give it a task and check the result. We then point out mistakes and ask it to try again.

The Gauntlet Loop automates much of this process.

The builder creates something and the critic checks it. If something is wrong the builder gets feedback and tries again. This continues without us writing another prompt every few minutes.

Example: An AI agent builds a website and runs browser tests. It finds a broken mobile menu so it fixes the issue and tests again. It can keep working through other problems for hours.

This changes AI from something we constantly chat with into something that can keep working while we’re away.

5. Weaponized persistence — Better process can beat smarter models

Perhaps the most interesting idea behind the Gauntlet Loop is that a better process can sometimes matter more than a smarter AI model.

A powerful model that gets one attempt might produce worse results than a less powerful model that gets several rounds of testing and feedback.

Example: An AI agent builds an app with slow database queries and broken login flows. The first version isn’t great. But after several rounds of reviews and fixes it produces a much better app.

The model hasn’t suddenly become smarter. The process keeps pushing it to find and fix mistakes. With the right feedback this persistence can help a less powerful model produce better results than a smarter model that only tries once.

The Gauntlet Loop shows us that better AI results aren’t always about smarter models or longer prompts. For us developers the real skill is knowing how to build systems that check the work and catch mistakes until the result is good enough.