featured

This is one of the most essential skills that every developer should have.

The /feature-dev skill plugin makes you write code with far fewer mistakes, spend less time fixing AI-generated code and make much better architectural decisions.

It does this through specialized AI agents that handle different tasks and a structured seven-step workflow that takes you from understanding your codebase to building and reviewing your feature.

Multi-agent specialization: Better codebase understanding and fewer mistakes

Normally one AI agent handles everything from reading your code to planning and reviewing it.

Feature Dev uses three specialized agents:

• code-explorer: Goes through your codebase to understand how things work and trace dependencies without changing files.
• code-architect: Plans the feature and suggests different approaches while spotting possible problems.
• code-reviewer: Checks for bugs and type issues. It also looks for security risks and possible regressions.

This lets each agent focus on one task instead of handling everything in the same context.

For us developers this means fewer mistakes caused by missing context. It also reduces duplicate code and the risk of breaking existing features.

Seven-step workflow: Less back-and-forth and more predictable development

Feature Dev doesn’t just take your prompt and start coding.

It follows seven steps:

1. Discovery: Understand what you want to build.
2. Codebase exploration: Look through your existing code.
3. Clarifying questions: Ask about anything that’s unclear.
4. Architecture: Plan how to build the feature.
5. Implementation: Write the code.
6. Quality review: Check the code and run relevant tests.
7. Summary: Explain what changed and prepare the work for review.

This gives you a clear picture of what’s happening at each stage.

Instead of constantly correcting the AI with new prompts you get a more organized process. You can review important decisions and catch problems early.

Upfront clarification: Less rework and fewer wasted hours

One frustrating thing about AI coding tools is how quickly they make assumptions.

Say you ask Claude to add file uploads to your app.

It should first ask questions like:

• What file types should users upload?
• What’s the maximum file size?
• What happens when an upload fails?
• Where should the files go?

A regular AI assistant might make these decisions without asking you.

Feature Dev asks questions before writing code so you can clear up missing requirements early.

This means less time fixing misunderstood requirements and fewer unnecessary code changes.

It’s easier to answer a few questions upfront than to rewrite several files because the AI made the wrong assumptions.

Architectural trade-offs: Less technical debt and more control

Instead of choosing one approach and immediately writing code the code-architect agents explore different ways to build your feature.

They compare things like:

• Complexity: How difficult is the solution?
• Maintainability: How easy will it be to change later?
• Existing code: How much needs to change?
• Trade-offs: What do we gain or lose?

You then choose what makes the most sense for your project.

Say you’re adding caching. You might prefer a simple in-memory solution instead of Redis depending on your app’s needs.

This helps us avoid unnecessary complexity and technical debt while keeping you in control of the architecture.

Persistent artifacts: Easier handoffs and less lost context

One problem with AI coding sessions is losing track of decisions when you pause your work or hand it over to a teammate.

You can make Feature Dev more useful by pairing it with Markdown files like:

• proposal.md: What we’re building and why.
• design.md: How we’ve decided to build it.
• tasks.md: What’s done and what’s left.

Feature Dev doesn’t create these files by default. But you can combine it with tools like OpenSpec or your own instructions.

This makes it easier to resume work and share plans with teammates. You can also review code against the original design without digging through a long AI conversation.

Feature Dev gives us a clearer process and more control over how we build features with AI.

You might not need it for small fixes. But for complex features it can save time and help you avoid unnecessary mistakes.

The goal isn’t just to write code faster. It’s to spend less time fixing mistakes and more time building the right thing.

/goal is a powerful Claude Code command that makes your agent much more reliable and frees up the time you have spend watching over them.

It lets you give Claude an end state and have it keep working until it gets there.

Instead of prompting Claude one turn at a time and checking if it has achieved the results you want, you can define a clear result:

Plain textCopied!

/goal all tests in test/auth pass and lint is clean.

Claude then works across multiple turns. It tests its changes, responds to failures and keeps going until the goal is met or it needs you to step in.

This makes Claude Code much more useful for longer tasks like debugging, refactoring and migrations — you spend less time managing the agent and more time on higher-value work.

1. Goal-oriented execution: Spend less time supervising the agent

A normal coding-agent session often looks like this:

Plain textCopied!

Prompt → Work → Stop → Continue → Work → Stop

/goal changes the loop:

Plain textCopied!

Goal → Work → Evaluate → Continue → Evaluate → Done

Claude checks the goal after each turn. If it has not reached the goal it keeps working.

This works well for migrations, refactors and test fixes — tasks that often need several attempts.

You free up your time as you no longer have to constantly supervise the mode. You define the outcome and spend more time on architecture, reviews or other work.

The key is to define a clear finish line:

Plain textCopied!

/goal all authentication tests pass,

lint is clean and public APIs remain unchanged

You define where Claude needs to get — Claude works out the steps.

2. Evidence-based verification: Know that “done” really means done

More autonomy creates a problem. What stops Claude from deciding that the work is complete too early?

/goal separates doing the work from checking it.

The main Claude model writes code and uses tools. After each turn a smaller model checks whether the goal has been met.

It can use evidence that shows up during the session:

Plain textCopied!

42 tests passed

0 failed

npm run lint

Process exited with code 0

That is stronger than Claude simply saying the problem should now be fixed.

The evaluator does not run commands itself — it checks the evidence already available in the conversation.

This creates a stronger definition of “done” for you. Tests, compiler output and command results can show that the work actually meets the goal.

3. Continuous self-correction: Debug for longer without stepping in

Most bugs do not disappear after the first fix.

Claude might change some code and run the tests. Three fail.

With a normal session it may stop and wait for another prompt.

With /goal those failed tests show that the goal is incomplete — so Claude can keep working.

Plain textCopied!

Change → Test → Observe → Evaluate → Adapt → Test Again

Claude reads the error, changes its approach and tests again. It can also use background commands or delegated subagents during harder investigations.

For us developers this means fewer interruptions during debugging.

A bug that takes several attempts can become one continuous process — failure becomes feedback for the next attempt instead of the end of a turn.

4. Cost and quota protection: More autonomy without runaway usage

Continuous execution also creates risk.

If Claude gets stuck it could keep trying similar solutions while using more tokens.

Claude Code includes safeguards for this. It can detect several turns without useful tool activity or progress — then stop and return control to you the developer.

Goal checks also use a smaller and faster model by default.

So Claude Code can use the more capable model for engineering work — then use a cheaper model to check whether that work is complete.

You get more autonomy without giving the agent an unlimited license to keep running when progress stalls.

5. Session persistence: Hand off work that takes longer

Not every engineering task fits into one sitting.

Claude Code lets you resume sessions with commands like claude --continue and --resume. Active /goal state can carry into the resumed session.

If your goal was:

JavaScriptCopied!

/goal all acceptance criteria are implemented

and the payment tests pass

Claude can return to that same finish line later.

This makes /goal useful for larger migrations, implementations and debugging sessions — not just quick tasks.

More broadly, /goal changes how developers work with coding agents.

Instead of managing each step: Fix this, Run the tests, Try again, Continue… you define the outcome:

Here is the state I want.

Here is how we know it works.

Keep going until that is true.

You define the finish line — Claude finds the path.

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.