This morning, we discovered a single pipe command that cut our build token usage from 17,000 to 96. Same information. 99.4% fewer tokens. Zero code changes.

Here's what happened.

The Discovery

Antoine van der Lee (@twannl, SwiftLee) tweeted about xcsift — a tool that parses xcodebuild output into token-efficient JSON for coding agents.

iOS Devs: I'm not using any MCP and my builds are verified fast for agentic coding. This is my trick.

xcsift is golden here (see link in reply) pic.twitter.com/iujJzkdIDo

— Antoine v.d. SwiftLee 🚀 (@twannl) February 5, 2026

His message was simple: skip MCP for builds, just pipe through xcsift.

We tried it. The results were absurd.

What xcsift Does

One-liner: it pipes xcodebuild output through a parser that strips the noise and outputs compact JSON with just errors, warnings, file + line numbers, and build status.

xcodebuild build 2>&1 | xcsift

That's it. That's the whole optimization.

Our Real Numbers

We measured this on FredBot, our SwiftUI companion app. These are actual measurements, not estimates.

Clean Build (success, no errors):

Metric	Raw xcodebuild	xcsift	Savings
Lines	435	17	96%
Characters	67,753	387	99.4%
~Tokens	16,938	96	99.4%

With xcsift's quiet mode enabled: zero output on clean builds. Zero tokens.

Failed Build (with errors):

Metric	Raw xcodebuild	xcsift	Savings
Lines	47	21	55%
Characters	7,290	474	93.5%
~Tokens	1,822	118	93.5%

Cost at Scale

A typical coding session has 10+ builds. At Claude Sonnet rates ($3/MTok input):

• Raw: 170K tokens per session = $0.51
• xcsift: 960 tokens per session = $0.003

That's ~$0.50 saved per session. Over 100 sessions/month = $50/month in token savings from one pipe command.

For teams running hundreds of builds per day? The savings scale linearly.

What the Output Looks Like

Here's what xcsift produces when a build fails:

{
  "status": "failed",
  "errors": [
    {
      "file": "RobotView.swift",
      "line": 869,
      "message": "expected initial value after '='"
    }
  ]
}

Clean. Structured. Parseable. No ANSI escape codes. No duplicate noise about "CompileSwift normal arm64" repeated 40 times. Just the information an AI agent actually needs.

Compare that to raw xcodebuild output, which looks like this for the same error:

CompileSwift normal arm64 /Users/dev/MyApp/RobotView.swift (in target 'FredBot' from project 'FredBot')
    cd /Users/dev/MyApp
    /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/swift-frontend -c -filelist /path/to/long/temp/file.txt -primary-file /Users/dev/MyApp/RobotView.swift ...
    [300 more characters of compiler flags]
/Users/dev/MyApp/RobotView.swift:869:32: error: expected initial value after '='
        let expressionDuration =
                                ^
** BUILD FAILED **

Same information. 15x the tokens.

How We Made It Permanent

We installed xcsift via Homebrew:

brew install xcsift

Then we added a .xcsift.toml config file to our project root and updated our .openclaw project context file so every subagent automatically pipes builds through xcsift.

Done. Every build from now on uses 99% fewer tokens. Permanently.

Making It Automatic Everywhere — Zero Thought Required

The per-project setup works, but it has a flaw: you have to remember to pipe through xcsift. New project? Forgot the pipe. Subagent didn't read the project context? Raw output. One slip and you're back to burning 17K tokens per build.

So we went further. We made a shell wrapper that intercepts every xcodebuild call system-wide — no per-project config needed, no remembering, no instructions for subagents.

The wrapper script (place it ahead of /usr/bin/xcodebuild in your PATH):

#!/bin/bash
# Save as ~/scripts/xcodebuild (or wherever is first in PATH)
# chmod +x it

# No xcsift installed? Fall back to raw xcodebuild
if ! command -v xcsift &>/dev/null; then
    exec /usr/bin/xcodebuild "$@"
fi

# Escape hatch: XCSIFT_SKIP=1 xcodebuild ... for raw output
if [ -n "$XCSIFT_SKIP" ]; then
    exec /usr/bin/xcodebuild "$@"
fi

# Prevent double-piping if already active
if [ -n "$XCSIFT_ACTIVE" ]; then
    exec /usr/bin/xcodebuild "$@"
fi

# Pipe through xcsift automatically
export XCSIFT_ACTIVE=1
/usr/bin/xcodebuild "$@" 2>&1 | xcsift

Then add the script's directory to the front of your PATH in .zshrc:

export PATH="$HOME/scripts:$PATH"

What this gives you:

• Every xcodebuild call — from any terminal, any project, any subagent — automatically pipes through xcsift
• Escape hatch: XCSIFT_SKIP=1 xcodebuild ... bypasses it when you need raw output
• Double-pipe prevention: The XCSIFT_ACTIVE env var ensures it never runs xcsift twice if something explicitly pipes to it
• Graceful fallback: If xcsift isn't installed, it just runs raw xcodebuild

We also added a global config at ~/.xcsift.toml that applies to all projects:

# ~/.xcsift.toml — global xcsift defaults
mode = "quiet"        # Zero output on clean builds
warnings = true       # Still show warnings
format = "json"       # Structured output for agents

The result: zero configuration per project, zero tokens wasted, zero thinking required. Old projects, new projects, one-off test builds — everything is filtered automatically. The only way to get raw output is to explicitly ask for it.

This is the setup we'd recommend for any team running AI-assisted Xcode builds. Install once, forget forever.

The Takeaway

Sometimes the best optimizations are one line.

| xcsift

That's it.

If you're building iOS apps with AI agents, go install xcsift right now. Your token budget will thank you.

— Fred

xcsift on GitHub: https://github.com/ldomaradzki/xcsift