How to Add a Health Check to a Raid Workflow
- Published
- Author
Alex Salerno
Use the Raid `Wait` task to block on HTTP endpoints or TCP ports until a service is healthy — and pair it with `Group` for retry semantics on flaky deps.
Read moreBlog
Blog posts on software, systems, and side projects—everything I'm building, learning, or thinking about.

Use the Raid `Wait` task to block on HTTP endpoints or TCP ports until a service is healthy — and pair it with `Group` for retry semantics on flaky deps.
Read more
Bootstrap a multi-repo workspace in one command. `raid install` clones every repo in your profile in parallel, runs install tasks, and is fully idempotent.
Read more
Commit a raid.yaml to any repo so the Raid CLI can run its commands, environments, and install steps — and merge them with the team profile automatically.
Read more
Create a Raid CLI profile five ways: interactive wizard, hand-written YAML, an existing raid.yaml, a Git URL, or a raw file URL. With trade-offs and a decision guide.
Read more
Diagnose Raid failures fast: read the exit-code category, decode the structured error envelope, use `raid context`, and apply per-task `continueOnFailure` for noisy steps.
Read more
Define a custom `raid <name>` command by composing the eleven built-in task types — Shell, Script, Git, HTTP, Wait, Template, Prompt, Confirm, Print, Set, and Group.
Read more
AI coding agents work much better when they can see your whole workspace. Here's how to give Claude Code, Cursor, or any MCP-compatible agent context across every repo at once.
Read more
Developer toil — the manual setup, the stale wiki, the "what's the command for that again?" Slack thread — is fixable. Here's how to cut it systematically.
Read more
Install the Raid CLI on macOS, Linux, or Windows — stable and preview channels, verifying the install, upgrading, and uninstalling.
Read more
Environment drift is the silent cause of "passed in staging, failed in prod" incidents. Here's a model for keeping them in sync without a config-management framework.
Read more
The phrase is a meme because it's almost never true. Here's how to make local development environments consistent enough that 'works on my machine' becomes a real signal.
Read more
Multi-repo (polyrepo) development gets a bad reputation it doesn't deserve. The problem isn't the repos — it's the lack of a layer above them. Here's the layer.
Read more
Move from per-project task runners (Make / Taskfile / Just / docker-compose) to Raid for multi-repo orchestration — with side-by-side conversions and a wrap-don't-replace strategy.
Read more
Most engineering onboarding takes days. It doesn't have to. Here's the shape of an onboarding flow where a new hire is running the stack and making commits the same morning.
Read more
Use `concurrent: true` and Group `parallel: true` to fan out Raid tasks across CPU cores — with the safety rules, output prefixing, and when not to parallelize.
Read more
Distribute a Raid CLI profile across a team — Git repo, raw URL, or committed-in-monorepo — with versioning, rollout, and update strategies.
Read more
Every team has the script. It works until it doesn't. Here's how to replace `setup.sh` with something the team can actually rely on — without rewriting your tools.
Read more
Use `raid env <name>` to switch every repo in your profile to local, staging, or production at once — variable scoping, repo overrides, and the merge rules.
Read more
Run `raid context serve` to expose your multi-repo workspace to AI agents over MCP — six tools, six resources, JSON-RPC over stdio, no network exposure.
Read more
Build interactive Raid workflows: collect input with Prompt and Confirm, generate files from templates with the Template task, and stay safe in headless / CI mode.
Read more
Run Raid in CI without prompts or hangs: `--yes` / `--headless` flags, `--json` output, exit-code categories, and patterns for GitHub Actions and friends.
Read more
Make, Taskfile, Just, and Raid each solve different problems. Here's an honest comparison — what each is best at, where each falls short, and how to pick.
Read more
The monorepo-vs-polyrepo debate frames the wrong axis. Most teams don't actually need to pick — they need a layer above their repos that handles team-level orchestration.
Read more
Most runbooks rot the day after they're written. The fix isn't a better wiki — it's making the runbook executable and version-controlled so the team can't ignore it.
Read more
Slow developer setup is rarely about hardware. It's almost always about coordination overhead — and it has a recognizable shape that's worth diagnosing before throwing tools at it.
Read more
A silly co-op multiplayer browser game built entirely on the Cloudflare edge stack. Why Durable Objects are the right primitive for multiplayer state, the math behind the cooldown that makes the game cooperative instead of competitive, and what it taught me about WebSockets at scale.
Read more
A year after the design proposal, an honest retrospective on _Raid_ — the multi-repo workflow orchestrator I built to escape my own toil. Architecture, key design decisions (including agent-native MCP integration), what got cut, and what I learned along the way.
Read more
My design proposal for Raid, an open-source command-line tool that streamlines development across distributed codebases. Raid orchestrates tasks, environments, and dependencies through a simple, configurable YAML system.
Read more