Migrating a Workflow to Claude Code Skills Without Breaking It

Greenfield agents are easy to talk about and rare in practice. Most of the time you're not building from nothing — you're taking a workflow that already runs, that people depend on, that has years of edge cases baked into it, and trying to move it onto an agentic approach without breaking the business in the process. That migration is its own discipline. Done carelessly, you replace a predictable process with an unpredictable one and erode trust on day one. Done well, you de-risk every step and earn the right to expand. This post is the playbook.

Map the workflow before you touch it

The first mistake teams make is automating a workflow they don't actually understand. Before any Skill gets written, document what the existing process really does: the inputs it accepts, the steps a human takes, the tools and systems involved, the decision points, and — most importantly — the exceptions. The exceptions are where the value and the danger both live, because they're the cases your eventual agent will get wrong if you don't account for them.

Pay special attention to the implicit knowledge. Experienced operators carry rules in their heads that were never written down: "if the customer is enterprise, route it differently," "never auto-approve over this amount." These tacit rules are exactly what a fresh agent has no way to know. Surfacing them now, in plain language, is what will later become the core of your Skill's instructions. A Skill is a folder of instructions and resources Claude loads when a task is relevant — and the quality of those instructions is mostly determined by how well you captured the real workflow here.

Define success explicitly while you're at it. What does "the agent did this correctly" mean for this workflow, in measurable terms? You'll need that definition to build evals and to decide, later, whether the migration is actually working.

Start in shadow mode

The safest first deployment is one that changes nothing the user sees. In shadow mode the agent runs alongside the existing process on real inputs, produces its output, but takes no real action — its result is logged and compared against what the human or legacy system did. You get a stream of real-world test cases at zero risk, and you find out exactly where the agent and the current process disagree before a single customer is affected.

Those disagreements are gold. Each one is either an agent bug to fix or a case where the agent is actually right and the old process was inconsistent. Either way you learn, and you accumulate a corpus of real cases that becomes your eval suite. Stay in shadow mode until the agreement rate is high enough that you'd trust the agent on the cases it's confident about.

flowchart TD
  A["Map existing workflow"] --> B["Run agent in shadow mode"]
  B --> C{"Agreement rate high?"}
  C -->|No| D["Fix Skill, add eval case"]
  D --> B
  C -->|Yes| E["Cut over low-risk slice"]
  E --> F{"Metrics healthy?"}
  F -->|No| G["Roll back to human"]
  G --> D
  F -->|Yes| H["Expand scope gradually"]

Resist the urge to skip this step because the demo looked great. A demo proves the agent can succeed once; shadow mode proves it succeeds on your messy real traffic, which is a completely different and much higher bar.

Cut over incrementally, by slice

When you do go live, don't flip the whole workflow at once. Carve off the smallest, lowest-risk slice first — the simplest case type, the lowest-stakes segment, a small percentage of volume — and let the agent handle that for real while everything else stays on the old path. This contains the blast radius of any problem to a corner of your operation instead of all of it.

Expand the slice only as the metrics earn it. Each time you widen scope, watch the same numbers you defined as success, and be ready to narrow again if they slip. The progression is deliberate: simplest cases first, then harder ones; low stakes first, then higher; small volume, then more. By the time the agent is handling the difficult, high-stakes cases, it has already proven itself on thousands of easier ones and you have real confidence rather than hope.

Keep the human in the loop at the boundary. Let the agent handle what it's confident about and hand off the rest to a person, rather than forcing it to attempt everything. A hybrid that automates 70% reliably is worth far more than a full automation that's wrong often enough to need constant cleanup.

Build the guardrails before you need them

Every migration needs a fast, boring way to turn the agent off. Put the agentic path behind a flag you can flip instantly, so that if something goes wrong the workflow falls back to the human or legacy process without an emergency deploy. Knowing you can roll back in seconds is what lets you move forward at all; without it, every expansion feels too risky to attempt.

Pair the kill switch with live monitoring on the metrics that define success, plus alerts on the failure signals — error rates, escalation spikes, anomalous actions. The goal is to detect a problem from your dashboards, not from an angry customer. And carry over the hard limits from the old process explicitly: the spending caps, the approval thresholds, the "never do X automatically" rules. Those constraints existed for good reasons, and the agent must inherit every one of them or it will eventually find the gap.

Treat the rollout as ongoing, not finished

A migration isn't done when the agent goes fully live; that's when the second phase starts. The workflow will keep changing — new case types, new tools, new policies — and the Skill has to evolve with it. Feed production behavior back into your evals so that as reality drifts, your quality bar drifts with it and keeps catching regressions. An agent that was excellent at launch and never updated will slowly diverge from the job it's actually being asked to do.

There's also a human side that determines whether the migration sticks. The people who used to run this workflow need to understand what the agent does, trust how it behaves, and know how to step in when it hands off. Bring them in early, show them the shadow-mode results, let them help define the exceptions, and the rollout becomes something the team adopts rather than something imposed on it. The technically perfect migration that nobody trusts gets quietly turned off; the slightly imperfect one the team helped build gets defended and improved. Plan for the latter.

Frequently asked questions

What is shadow mode and why use it first?

In shadow mode the agent runs on real inputs alongside the existing process but takes no real action — its output is logged and compared to the human or legacy result. It gives you a stream of real-world test cases at zero risk and surfaces exactly where the agent disagrees with current practice before any customer is affected.

How do I roll out an agent without breaking the existing workflow?

Map the real workflow including its exceptions, validate in shadow mode, then cut over the smallest low-risk slice first and expand only as metrics stay healthy. Keep the agentic path behind an instant kill switch and inherit every hard limit from the old process.

Should the agent handle the whole workflow or just part of it?

Usually part of it, at least at first. Let the agent take the cases it's confident about and hand the rest to a human. A hybrid that reliably automates most of the volume beats a full automation that's wrong often enough to require constant cleanup.

Is the migration finished once the agent is live?

No. The workflow keeps evolving, so feed production behavior back into your evals to catch drift, keep the Skill updated as policies and tools change, and keep the team that owns the workflow involved so they trust and improve it over time.

Bringing agentic AI to your phone lines

Moving a phone workflow onto an agent is exactly this kind of careful migration — shadow first, cut over by slice, and never lose the ability to fall back to a person. CallSphere brings this safe rollout discipline to voice and chat, so your lines get more automated without ever going dark. See it live at callsphere.ai.

---

Source & attribution: This is an independent, original explainer inspired by Anthropic's coverage on the Claude blog. Claude, Claude Code, Claude Cowork, Claude Opus, and the Model Context Protocol are products and trademarks of Anthropic. CallSphere is not affiliated with or endorsed by Anthropic.