Most of the "I built an AI workflow" posts you see on here treat Claude like a fancy text box. Open chat, paste prompt, copy answer, ship.

That's fine for solo dev tasks. It falls apart fast when you start building for someone else's business, especially one with strict confidentiality, compliance baggage, and a workflow that runs on documents.

I've been building Claude-powered tooling for law firms for the last year. The vertical doesn't matter as much as you'd think. Replace "motion to compel" with "engineering change order" or "policy underwriting memo" and the architecture is roughly the same. So if you're building for accountants, doctors, financial advisors, contractors, or any regulated professional services niche, this maps over cleanly.

Here's the stack I keep coming back to, and the part most people miss.

The mental model: Claude is not a chat tool, it's a runtime
The biggest unlock isn't a prompt trick. It's realizing that Anthropic shipped a layered platform and the chat window is just the entry point.

Here's what's actually available:

• Projects for persistent workspaces with files and instructions
• Skills for reusable instruction packs that encode style and process
• MCP connectors for plugging into Drive, Gmail, Calendar, Slack, and custom servers
• Cowork for agentic multi-step task execution
• Artifacts for shippable interactive UI generated inline
• Memory for cross-conversation context on Max
• Claude Code for terminal-native dev workflows
• The API for when you actually need to build a product

If you stop thinking of these as features and start thinking of them as primitives in a stack, the architecture writes itself.
The architecture that works

For a vertical use case, here's the layering I've landed on after a lot of dead ends.

Layer 1: Projects = workspace per "matter"

In law it's a case. In your vertical it's probably an account, a project, a client engagement, a deal. Whatever the long-running unit of work is, that's a Project.

Inside, you load:

The reference documents that define the engagement
Project-level instructions that pin the rules of the road (jurisdiction, style, default outputs, things to never do)
The output history, which becomes its own context over time

Skip this and every conversation is cold-start. Use it and Claude walks in pre-loaded.

Layer 2: Skills = your firm's playbook as code

Skills are the most underrated thing Anthropic has shipped. They're literally a SKILL.md file plus optional supporting assets, and they tell Claude how to do a specific kind of work the way your team does it.

For a law firm I built a Skill for demand letters. It encodes structure, citation format, tone, the partner's pet phrasings, and the things never to include. Now any associate at the firm can fire it and get output that looks like the senior partner wrote it.

The pattern generalizes hard:

skills/
demand-letter/SKILL.md
client-intake-summary/SKILL.md
discovery-response/SKILL.md
weekly-status-update/SKILL.md

Each one is your team's institutional knowledge in a file. Versioned. Reviewable. Shareable across the org. This is the part that compounds.

Layer 3: MCP for the boring plumbing

Claude has direct connectors for Google Drive, Gmail, Calendar, Slack, GitHub, and a growing list. You can also write your own MCP server for whatever niche tool the vertical lives in (legal practice management, EHRs, CRMs, ERPs, you name it).

The win here is removing the file shuffle. Without MCP, the workflow is: download from system A, upload to Claude, get answer, paste into system B. With MCP, Claude reads from system A and writes to system B in the same turn.

If you're building for a vertical, writing one custom MCP server for the dominant tool in that niche is probably the highest-leverage thing you can do. Most verticals have one or two systems of record everyone uses, and nobody has built the connector yet.

Layer 4: Cowork for the multi-step stuff

Cowork is Anthropic's agentic mode. You describe an outcome, Claude works through the steps, only checks in when it actually needs you. This is where Claude stops being reactive and starts being a junior team member.

Concrete example I built recently: "review these eight discovery documents, extract every date mentioned, identify the source for each, and produce a chronological timeline grouped by topic." Without Cowork, that's thirty back-and-forths. With Cowork, it runs.

For your vertical, look for tasks that are:

• Multi-document
• Sequential (output of step N feeds step N+1)
• Tedious enough that nobody actually does them well

Those are Cowork tasks. Build for them first.

Layer 5: Claude Code when you're ready to build

If your client (or your own team) has anyone semi-technical, Claude Code is genuinely transformative. I've watched a paralegal with no coding background ship a working intake automation in a weekend with it. Marketing operators are building content pipelines. Office managers are wiring up internal AI agents.

The interesting thing for devs reading this: you're now competing on architecture, not on writing code. The leverage is in knowing what to build and how to structure it. The actual code generation is solved.

Layer 6: API when you need a real product

Once a workflow stabilizes inside the Claude UI, the next move is usually to lift it into an API-backed product. Client-facing chatbot, internal tool, customer dashboard, whatever. Pricing is pay-as-you-go and for most B2B use cases the monthly bill lands somewhere reasonable.

Half the legal AI startups charging four figures a month are wrapping the same API you have access to. That's not a knock on them, it's just an observation. If your vertical has a SaaS charging $500 per seat for AI features, you can probably build a focused alternative for one customer at a fraction of the cost.

The part nobody warns you about

Three failure patterns I see constantly when teams try to roll this out:

• They never set up Projects. Use the chat window, get tired of re-uploading the same files, decide Claude is "too manual." The fix is fifteen minutes of setup that nobody does.
• They never write Skills. Get good output once, never encode it. Every prompt is from scratch. The compounding never kicks in.
• One person uses it well, nobody else adopts it. A single power user produces magic, the rest of the org watches. Without shared Projects and Skills, the firm just has one person who is good at AI, not an AI-augmented firm.

The technical fix for all three is the same: treat the Claude stack as infrastructure, not as a personal tool. Version-control your Skills. Document your Projects. Onboard people into the stack the same way you'd onboard them into your codebase.

The vertical play

If you're a developer or solo operator looking for an angle, here's the unsexy advice: pick a vertical, learn its workflow obsessively, build the stack above for it, and ship.

Every regulated professional services niche has the same shape. Long-running engagements, dense documents, repetitive output, strict compliance. The same architecture works across all of them. The differentiation is in knowing which Skills to build and which MCP connectors to write.

I went deep on the law firm version of this and wrote it up over on Lawyer's Marketer if you want the full vertical breakdown of which Claude tools map to which legal workflows: Claude Tools for Lawyers: Move the Needle In Your Practice. It's written for lawyers but the architecture translation is pretty obvious if you read it as a developer.

Parting thoughts

The chat window is the demo. The stack is the product. If you're building anything serious on Claude, stop benchmarking against ChatGPT and start thinking like a platform engineer. The teams shipping real value right now are the ones treating Projects, Skills, MCP, and the API as a coherent stack rather than a checklist of features.

If you're working on something in this space, I'd genuinely like to hear what you're building. Drop it in the comments.