jtakeit
EN
Try for free
Menu
Try for free

Claude Code + MCP

Build client sites with Claude Code — on a backend made for agents

Claude Code writes the client’s static site in your repository — Astro by default. Through jtakeit’s MCP server it checks, builds and previews it, and jtakeit runs the panel, forms, bookings and hosting behind it.

Try for freeConnect the MCP server ↓
claude — client-site
$ npx @jtakeit/astro create client-site --locale en
$ cd client-site && npm ci
$ claude
> Write the site from the brief. Make the hero, the
  questions and the form editable, then run the
  catalogue check and push.
Claude Code works in the repository like any other developer would.

01/ connect

Connect the MCP server

Two commands in Claude Code and one approval in the panel. Any client that speaks MCP connects the same way — Claude Code is the example here.

zsh — claude code
$ claude mcp add --transport http jtakeit https://mcp.jtakeit.com/mcp
$ claude mcp login jtakeit
# the panel opens in your browser — approve, and it's done
In Claude Code: add the server, then sign in.
mcp.json — any MCP client
{
  "mcpServers": {
    "jtakeit": {
      "type": "http",
      "url": "https://mcp.jtakeit.com/mcp"
    }
  }
}
Any other MCP client: the same server, in its configuration.
  1. 1

    Add the server

    Add jtakeit’s MCP server to your agent: two commands in Claude Code, or a few lines of configuration in another MCP client.

  2. 2

    Approve it in the panel

    Your MCP client opens the jtakeit panel in your browser. You sign in and approve the connection.

  3. 3

    Done — no key to copy

    No API key is shown or copied. The access belongs to you, and you revoke it in the panel under Agents — it stops at once.

Then ask

Ask in plain words. The agent sets up the project, writes the pages, builds the site and gives you a preview link for the client.

claude — client-site
$ claude
> Create a site for my client's barbershop on jtakeit

02/ the flow

Build a website with an AI agent, from scaffold to preflight

The agent works in two places: in the git repository, where it writes and checks the site, and on the platform, through jtakeit’s MCP server, where it builds, previews and checks it again.

zsh — client-site
# in the repository
$ npx @jtakeit/astro catalogue
# writes jtk/catalogue.json, builds the site and checks
# every page against it — both directions
$ git push origin main
mcp — jtakeit
# then over MCP, from the agent
validate_catalogue   # judges the pushed commit, all findings at once
create_site          # the site on the platform
attach_repo          # imports the branch
commit_and_build     # the first build — nothing goes public
get_build            # until it settles; get_build_log if it fails
get_built_page       # read what was actually built
get_preview_link     # the link a person looks at
preflight            # before anyone says it is done
  1. Write. The pages, what the owner may edit, and the words — all files in git. Astro is the default; any static generator can be laid out to the same contract.
  2. Check locally. The catalogue check refuses a field that is declared and not rendered, or rendered and not declared.
  3. Build. The first build takes under a minute on the Astro scaffold, about 90 seconds on another generator, and nothing goes public.
  4. Preflight. The last check before anyone calls it done — and the client signs off on a preview before they pay.

03/ the tools

The MCP server: 24 tools

jtakeit speaks the Model Context Protocol, so the agent calls the platform the way it calls anything else: by name, with a result it can read. These are all of them.

Sites

  • create_site
  • get_site
  • list_sites
  • attach_repo
  • import_branch

Builds

  • commit_and_build
  • trigger_build
  • get_build
  • get_build_log
  • get_built_page
  • rollback

Checks

  • validate_catalogue
  • get_registry
  • preflight
  • get_preview_link

Dev session

  • open_dev_session
  • get_dev_files
  • send_dev_catalogue
  • close_dev_session

Content & account

  • get_content
  • list_entries
  • get_stats
  • get_allowance
  • get_prices

04/ the limits

What the agent can’t do — on purpose

Some decisions belong to a person. The platform is built so that an agent cannot take them:

  • It cannot read the client’s customers — enquiries, bookings or members.
  • It cannot change a site’s structure through a tool. Structure is a commit and an import, which you can read and review.
  • It cannot launch a site on its own domain, invite anybody or connect another agent. A person does that in the panel.
  • On a launched site, its build is a candidate. A person publishes it.

05/ dev session

The dev session: your local server, with the owner’s real text

A dev session frames the local dev server with the owner’s real text before anything is pushed — so the agent’s next change is judged against the words the client actually wrote, not the placeholder it started from.

Where this fits in the bigger picture: the agent writes the site, and jtakeit, the backend for client sites, runs the panel, forms, bookings and billing. What the owner can edit is declared the same way as in any Astro CMS for client sites on jtakeit, and if you are weighing this against a visual builder, see jtakeit compared with Webflow.

06/ questions

Building with an agent

Can Claude Code build a website?
Yes. Claude Code writes files, so it can write a static site — on jtakeit’s Astro scaffold, or in Next.js, Nuxt, SvelteKit, Eleventy or Vite: pages, components and content. jtakeit gives it a scaffold to start from and an MCP server to build, preview and check the site, then runs the hosting, forms, bookings and payments.
How do I connect Claude Code to jtakeit?
Add jtakeit’s MCP server with two commands in Claude Code. The panel opens in your browser; you sign in and approve the connection. No API key is shown or copied, and you can revoke the access in the panel under Agents — it stops at once.
What is an MCP website builder?
A platform an AI agent drives through the Model Context Protocol. jtakeit’s MCP server has 24 tools: with them the agent checks what the owner may edit, creates the site, builds it, gets a preview link and runs the last checks before anyone calls it done.
What can the agent not do on jtakeit?
It cannot read the client’s customers: enquiries, bookings or members. It cannot change a site’s structure through a tool; that is a commit and an import. It cannot launch a site on its own domain, invite anybody or connect another agent; a person does that in the panel.
Do I still review what the agent writes?
Yes, and you can, because everything it writes is a file in your git repository. On a launched site an agent’s build is a candidate, and a person publishes it.
Does it only work with Claude Code?
No. Any client that speaks MCP connects the same way: add jtakeit’s MCP server and approve it in the panel. Claude Code is the agent this page shows, because it works with files and a terminal the way the flow above needs.

07/ try it free

Build your next client site with Claude Code

Sign up in the panel and build your first client site. Building and previewing cost nothing — you pay a wholesale price only when a site goes live.

Try for freeadmin.jtakeit.com

  • Free until a site goes live
  • Then a wholesale price per live site, from €5 a month
  • The code stays in your git repository