Uncategorised

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.

These are five Claude Code commands that massively upgrade the conversation experience.

They increase the overall usefulness of your conversations in your workflow, and improve developer quality of life.

1. Command 1 — Preserve your most valuable conversations forever

Some conversations with Claude are really worth keeping.

You might spend an hour fixing a tricky bug or working through how to build a new feature. That conversation could be useful again much sooner than expected.

Instead of letting it get buried in your terminal, you can save it.

Just type:

Plain textCopied!

/export

You can also save it straight to a file:

Plain textCopied!

/export debugging-session.txt

Claude saves the conversation as a text file.

You can share it with your team or turn it into documentation. You can also come back to it when you face a similar problem.

2. Command 2 — Fearlessly explore exciting new ideas without starting over

Sometimes you want to try a different approach to something you’re building.

You might be building an API with REST and want to see how the same thing would work with GraphQL.

You don’t need to throw away your current conversation or explain your whole project again.

Just type:

JavaScriptCopied!

/fork

This creates a new branch of your conversation.

You can explore your new idea while keeping the original conversation.

If the new approach doesn’t work out, you can go back to where you left off.

Just remember that /fork doesn’t create a separate Git branch. Use Git branches or worktrees if you want to keep your code changes separate.

3. Command 3 — Effortlessly copy Claude’s best responses in seconds

Claude often gives us useful code snippets and explanations that we want to use somewhere else.

Instead of manually selecting text from your terminal, just type:

JavaScriptCopied!

/copy

This copies Claude’s latest response to your clipboard.

If the response has several code blocks, you can choose which one to copy. You can also copy the whole response.

You can even copy an earlier response:

Plain textCopied!

/copy 2

This copies Claude’s second-most-recent response.

It’s a small command that saves you time when you need to share code or paste something into your docs.

4. Command 4 — Ask brilliant side questions without breaking your flow

This is one of my favorite commands.

Let’s say you’re working with Claude on a big feature and you come across something you don’t understand.

You can ask a quick question without interrupting your main conversation.

Just use /btw:

Plain textCopied!

/btw What does Partial<T> mean in TypeScript?

Claude answers your question using what it already knows about your conversation.

The best part is that the question and answer don’t become part of your main conversation.

So you can ask little side questions without filling your main chat with things that aren’t part of your main task

5. Command 5 — Seamlessly pick up your best conversations right where you left off

You can spend hours working with Claude on a feature. It knows your code and understands what you’re building. You’ve also made good progress.

Then you close your terminal.

When you come back the next day, you don’t have to start from scratch.

Just type:

JavaScriptCopied!

/resume

Claude shows you your previous conversations so you can pick one and continue.

You can also resume a conversation by its name:

JavaScriptCopied!

/resume authentication-refactor

This is useful when you’re working on a project that takes several days.

You can pick up where you left off without explaining everything again.

These five commands can save you a lot of time and make your conversations with Claude Code much more productive. Start using them to stay focused and get more done without constantly starting over.

This is absolutely incredible.

Claude Code just got two amazing new features that drastically improve how it works with external tools for building software faster.

First there’s the MCP/Plugin Tasks feature — before now Claude Code could never make calls to critical tools without blocking the main thread — and this led to serious wasted time and flow breakdown.

But now this has finally been fixed — Claude Code can now run extremely long tasks fully in the background — and still be able to work on any additional task of your choice.

Demo: Running tests with new Tasks feature — while doing other dev work at the time:

And this still wasn’t enough — they gave us another powerful feature.

Now with Elicitations, all your plugins can now directly interact with you in Claude Code — to get critical input from you — like asking for your personalized input or making sure you approve of sensitive actions.

Demo: Deploy a branch using the new Elicitations feature:

All this combines to save us hours, speed up our development, and give us much greater control over all our coding agents.

1. Asynchronous execution: No more blocking tool calls

Before now, MCP tool calls mostly worked like this:

• Claude sends a request to a tool.
• Claude waits for the tool to finish.
• If the tool takes too long, the request might time out.

MCP Tasks changes this complete.

The server can return a Task ID immediately and run the job in the background. Claude uses that ID to check progress while working on other things.

Real-World Scenario: You ask Claude to run a 15-minute security scan.

Instead of waiting, Claude can review your dependencies or write documentation. Once the scan finishes, Claude picks up the results.

2. Automatic backgrounding for older MCP tools

Your existing MCP servers don’t need to support the new Tasks feature to benefit from backgrounding.

Claude Code can automatically move eligible tool calls into the background after two minutes.

Real-World Scenario: An older MCP server takes five minutes to generate an analytics report.

• After two minutes, Claude backgrounds the call.
• Claude continues working.
• When the tool finishes, Claude gets the result.

You don’t need to rewrite your MCP server.

Older tools still have their usual timeout limits. Native MCP Tasks offer better support for long-running jobs.

3. Interactive elicitations: Claude can ask you for input

Sometimes an AI agent needs information it doesn’t have.

Instead of guessing or failing, MCP Elicitations let the tool ask you directly.

The server can show:

• A form for missing information or approval.
• A URL prompt for things like OAuth sign-ins.

Real-World Scenario: You ask Claude to deploy an application.

The deployment reaches production but needs your approval.

The tool asks you to confirm. You approve and the server continues.

You don’t need to restart the whole process.

4. Safety guardrails for unattended agents

Claude Code also handles tasks that need human input when nobody is available to respond.

If a task requests human input while Claude runs without an interactive terminal:

• Claude doesn’t guess an answer.
• It doesn’t wait forever.
• It asks the server to cancel the task.

Real-World Scenario: A GitHub Actions workflow starts a database migration.

Halfway through, the task asks for approval to delete an important table.

Since nobody can respond, Claude Code requests cancellation instead of approving the deletion.

The server still needs to handle cancellation safely.

5. Durable workflows: Tasks can keep running after you leave

With native MCP Tasks, the Claude Code MCP serve owns the task rather than your local Claude Code session.

This means remote tasks can keep running even if you close your terminal or lose your connection.

Real-World Scenario: You ask Claude to process a large dataset. The job takes two hours.

You close your laptop and return later.

If the server saved the task’s state, you can resume your Claude Code session and check the results.

Native background Tasks also have no default Claude Code execution time limit after acceptance.

But the server still controls task retention and retries.

These updates bring us closer to AI agents that can manage long-running workflows without constant supervision. For those of us building AI agents, this means less waiting and more reliable automation.

This is such an essential Claude Code skill to have in every coding workflow.

The To Spec skill massively elevates your development speed — especially when it comes to fleshing out a detailed, well-structured, and unambiguous set of requirements for a new feature or system.

It turns your conversations with AI coding agents directly into well-defined specifications that other agents can use to build your features.

And it even goes beyond this to handle other parts of the software dev lifecycle.

Five things that make it so special:

1. Future-proof specs that don’t crumble after refactoring

Unskilled AI-generated plans sometimes tell you exactly which files to edit — which makes the plans tightly coupled to your exact implementation.

Like if you’re adding subscription upgrades to your app. An AI might write:

Update src/services/subscriptionService.ts to handle upgrades.

But what if you move billing into another module? That instruction becomes useless.

To Spec avoids unnecessary file paths and code snippets. Instead, it records the actual planned high-level decisions:

Give users their upgraded features immediately and charge them only for the remaining billing period.

Now you can reorganize your code in the future without rewriting the spec.

The skill still includes exact schemas or data structures when you’ve already agreed on them and they make things clearer.

2. Rock-solid tests that survive code changes

Before writing your spec, To Spec suggests which parts of your feature you should test. It calls these testing boundaries.

Imagine you’re building an online checkout system that handles:

• Discounts and promo codes.
• Taxes and shipping fees.
• Payments and final totals.

An unskilled agent might test every small function separately. But when you change those functions, your tests could break even if checkout still works perfectly.

Instead, To Spec might suggest testing through the checkout API. Give it a cart, address, and discount code. Then check the final price.

The skill asks you to approve this testing approach first. It also prefers as few testing boundaries as possible, ideally one.

Now you can change your internal code without constantly fixing tests. Other AI agents also know exactly what to test.

3. A blissful end to endless AI questions

Here’s one of my favorite features.

To Spec explicitly tells the AI:

Do NOT interview the user; just synthesize what you already know.

Imagine you’ve spent thirty minutes deciding that:

• Admins can manage users.
• Editors can change content.
• Viewers can only read.

Then you ask for a spec, and the AI asks, “What roles should your app support?”

Frustrating, right?

To Spec takes those decisions straight from your conversation instead.

You make decisions during planning. The skill records them afterward.

No repeating yourself. No reopening questions you’ve already answered.

4. Crystal-clear specs that speak your codebase’s language

AI can build the wrong thing simply because it misunderstands your project’s terms.

Imagine your shopping app uses:

• Cart for items someone hasn’t bought.
• Order for completed purchases.

You’re adding a feature to save carts for later.

An AI might write:

Customers can save unfinished Orders.

But Orders only exist after checkout! That mistake could send the AI down the wrong path.

To Spec checks files like GLOSSARY.md and Architectural Decision Records (ADRs) to learn your project’s terms and technical rules.

So it writes:

Customers can save their Carts and return to them later.

Now the next AI agent knows exactly what you mean.

5. Effortless handoffs that keep AI agents moving

Most AI-generated specs sit in chat until you copy them into your issue tracker.

To Spec can publish them directly to:

• GitHub Issues.
• Linear.
• Local Markdown files under .scratch/.

Say you’ve finished planning a team invitation feature.

The skill can create the issue and add the ready-for-agent label, so another AI agent can pick it up and start planning the implementation.

You save yourself the copy-and-paste work. And the next agent gets the decisions it needs without another long explanation.

The bigger picture

The magic of To Spec isn’t simply writing specs. It’s making sure your decisions survive the journey from planning to implementation.

Less repetition, fewer misunderstandings, stronger tests, and smoother handoffs. That’s what makes it worth using.