Tari Ibaba

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.