FlowCastle vs "Just Use Claude Code"

"Why would I use a bot platform? I'll just ask Claude Code."

It's a fair question, and if you've tried it you know the first part goes well. Describe a Telegram bot, get working code, run it. The interesting part is what happens over the following weeks.

This is a comparison written by people with an obvious bias — we make the platform. So here's the least self-serving version of the answer we can give: it isn't a competition, and there are cases where the agent alone is the right call. Both are below.

They aren't competitors. One runs the other.

FlowCastle   →  the script    (what happens, in what order)
Claude Code  →  the executor  (the work inside a step)
MCP          →  the wiring    (how the agent reaches the tools)

Claude Code is an executor. A flow is the script it runs. You can point Claude Code at FlowCastle through our MCP server and build flows without leaving your editor — the agent reads the structure, proposes changes, and the platform validates them before they land.

So the real question isn't "agent or platform". It's what you want to be responsible for.

What you'd otherwise build yourself

This is the part that gets underestimated. The bot logic is a fraction of a working product. Everything below is already running:

That last row is the one people underestimate most. Answering customers from your own documentation — rather than from whatever the model remembers — means a retrieval pipeline: chunking, embeddings, a vector store, a search layer, and the glue that puts the right passage in front of the model. It's a project. Here you upload the documents and point a step at them.

Where the money and the hours actually go

• Time to first live bot. Generated code still needs somewhere to run, a deploy, secrets, a webhook, a domain. A flow is live when you finish it.
• Ops. Someone keeps the server up, patches it, and notices at 3am when it stops. That someone is you, or it's the platform.
• Model spend. This is the one worth stating carefully: a coding agent bills you for reasoning every time it works on the bot, and a fully agentic bot reasons on every incoming message. A flow executes its deterministic steps without calling a model at all, and fires the model only at the steps where you actually want judgment. Fewer calls, not free calls — our AI steps consume credits like anything else.

Structure instead of one enormous prompt

Short bots are fine as prompts. Long processes are where it changes.

• Adding capability is a module, not a rewrite. New step, new integration — you add it. You aren't re-engineering one giant prompt and re-testing everything it used to do correctly.
• Long processes stay in order. Plan, act, check, branch on the result. That order is a property of the flow, not of how well you phrased something.

One honest caveat on determinism, since it's the usual headline claim: a flow runs its steps in the same order every time, but AI steps are still AI, and an A/B split is random by design. Determinism is a property of the structure around the model, not of the model.

Reading it and changing it

This is the argument we've made at length elsewhere, so briefly: a flow is a diagram you can read, so you can see how the bot behaves without holding it all in your head, and you can change one step by opening it rather than by describing the change in a prompt and hoping nothing else moved.

The full version of that argument — including the strongest objection to it, that code in git is already reviewable — is in Your AI Agent Still Needs a Canvas.

When you should just use Claude Code

Genuinely, and this list is not short:

• A one-off script. Something you'll run twice and delete. Structure is overhead.
• Deeply custom logic that isn't a conversation — a scraper, a data pipeline, a build tool.
• You want to own the whole stack, have somewhere to run it, and consider that a feature rather than a chore.
• Exploring an idea. Nothing beats an agent for finding out whether a thing is worth building at all.

And if you land in the middle — mostly conversation, but with one weird part no visual editor should attempt — a flow has an HTTP-request step and a sandboxed custom-code step with access to your variables. Write that bit as code, keep the rest readable.

The short version

Claude Code gives you code. A platform gives you the product around it: hosting, CRM, analytics, live chat, payments and retrieval-backed AI, wired into a process you can see and change.

They compose. Use the agent for the parts that are genuinely code, and let it drive the platform over MCP for everything else.