Everything we've been asked,
no fine print.

Our desktop app, which wraps Claude Code like a dedicated assistant. You don't need an Anthropic subscription: you work through us, we don't charge a margin on tokens — we only charge you exactly what Anthropic charges us.

We've found that in most cases, developing this way ends up cheaper and simpler than a direct monthly Anthropic subscription.

No. We don't simulate Claude Code — we run it for real, against Anthropic's official API. The difference is in the wrapper: within minutes you get a managed environment (GitHub, database, deployment) and opinionated practices that ensure the code produced is high-quality and production-ready.

For people who want to build real applications without learning how to set up a GitHub repo, configure Supabase, connect Vercel, and maintain it all. If you know what you want to build but not how to wire up the infrastructure, we're the tool for you.

Technical users? There's a dedicated question below: in most cases it's worth it for them too, without needing a direct Anthropic subscription.

Not in the strict sense. We don't choose between models or orchestrate different models to save tokens — we leave that to Claude Code.

But because we pour our opinionated practices into every task based on our experience, that naturally reduces token usage. Less wasted work, fewer broken iterations, fewer tokens per task — not cheaper tokens, just less unnecessary work.

Our current priority is enabling people to start developing with Claude Code without a subscription and without technical knowledge. Deeper optimization will follow.

Real Claude Code, against Anthropic's official API. In our platform you can open multiple tasks simultaneously in the Tasks screen, and each task runs in a dedicated agent working in parallel with the main Claude Code instance and the other agents. You can currently run up to 3 agents in parallel within the same project.

In practice: instead of waiting for one task to finish before starting the next, you can push multiple development tracks in parallel on the same project (for example: fixing bugs while simultaneously developing new features) — just like running a full team of developers.

Not for everyone — it depends on usage patterns. In most cases, yes, for the following reasons:

• No 5-hour windows and no weekly cap. You pay only for tokens actually consumed, at Anthropic's API rates, with no margin.
• Pre-configured environment: GitHub, Supabase, Vercel — no need to set it up from scratch for every project.
• You can open multiple parallel tasks in Tasks (up to 3 agents simultaneously per project): each runs in a dedicated agent working alongside the main Claude Code, without waiting for one to finish before the next. You get faster development — like having a full team working for you simultaneously.
• Tests (unit + e2e) and code review are built in by default, not as a layer you have to remember to request.
• Infrastructure auto-scales to handle load — 10 users or 10,000, same environment.

When it's less suitable:

• If you have enterprise compliance requirements or very high traffic that needs precise infrastructure control, our managed stack will be too constrained.
• If you're a very heavy Claude Code user who consistently maxes out the 5-hour windows on a daily basis, a direct Anthropic subscription offers subsidized tokens that may end up cheaper at high consumption. More detail in the pricing question.

1. Sign up on the site and add a payment method.
2. Download the app.
3. Open a new project. The project goes live immediately — still without a finished app, but the infrastructure is already running.
4. Write your first prompt in the project's Current Workspace screen, describing in simple words what application you want to build. Claude Code builds, deploys, and returns a link on screen.
5. After the first prompt, the app likely won't be fully working yet — that's the quality review stage. Check what works and what doesn't, then write back to Claude Code in plain language about what to fix.
6. We recommend moving fixes and new features to the Tasks screen. There you can run multiple agents in parallel without waiting, and also manage a Wishlist with a clear status for each task.

Claude Code supports many languages and free-form conversation. Enjoy.

Important tip: it's best not to close the app while Claude Code is working.

There are two ways to work with us:

• Fully Managed (recommended for those just starting out): This is the default when creating a new project. We automatically set up a GitHub repo, a Supabase database, Vercel hosting, and a domain. You just describe what to build, and Claude Code gets to work.
• Import: For people who already have a GitHub repo they want to continue working on. Bring your repo link, and we enable Claude Code to work on it directly. This lets you develop your existing project through our app without us managing your hosting and database.

You can work in either mode per project. Different projects can use different modes.

On one side of the app there's a navigation panel with all your projects (PINNED at the top, and the rest under PROJECTS). Clicking a project opens it on the other side, with its different screens.

Below the project list you also have access to global screens not tied to a specific project: Usage, Feature requests, Support, and Settings.

Each project has 5 screens in the navigation:

• Current Workspace: The project's main chat. This is where you talk directly to Claude Code.
• Tasks: Task management and parallel execution. This is the recommended way to work after the initial build (details in the next question).
• Vault: Secure management of passwords, tokens, and secret keys.
• Versions: Project version history and rollback to a previous version.
• Run: Run the app locally on your machine, without waiting for deployment.

Additionally, at the top of each project there are three quick buttons:

• Play button (▶): Runs the app locally, like Run.
• Code agent selection: Claude Code by default. In the future, Codex, Cursor, and others will be added (you can vote on what you'd like us to support next).
• Globe button (🌐): Direct link to the project's live production site.

This is the recommended way to work after the initial build. The screen manages all open tasks for the project — a bug you spotted and want to fix, a feature to add, or an idea that's not yet fully defined. It's essentially an efficient project management system: you're in the CEO role, and Claude Code is your development team.

Tasks are also created automatically by Claude Code and the agents running in the project (for example, if they identify something worth fixing or improving while working).

Each task runs in a dedicated agent opened for it, working in parallel with Claude Code. You can run up to 3 agents in parallel in the same project. The Run by priority button lets Claude Code decide on its own the order in which tasks should be executed.

Task statuses:

• Backlog: New tasks wait here. Via the Run with Agent button you can open a dedicated agent for a task to start working on it immediately, or leave it pending for later.
• In Progress: The task's agent is currently running and working on it.
• Q/A: When the agent finishes its first pass, the task automatically moves here. This is the stage to review the output and have an improvement dialogue. The conversation happens inside the task's agent (not in the project's main chat). In most cases a few iteration rounds are needed to get things working exactly as you wanted — more detail in the question about how to work with AI.
• Done: When everything looks good, move it here.

You can also manually change any task's status.

In the Vault screen you manage passwords, tokens, and secret keys — for external tools you connect yourself, or tools we've pre-connected for you (Supabase for the database, Vercel for hosting).

This is information that, for security reasons, shouldn't be stored in the code itself. From Vault you can save it to Vercel or GitHub securely with a single click.

This is the community channel for suggesting improvements you'd like to see in Click Click Claude itself, and for voting on what matters to you. Votes directly influence our roadmap — what gets more votes gets in sooner.

Working with AI on code is a dialogue, not a transaction. The first prompt is a starting point, not a final output. After it:

1. Run what Claude Code returned.
2. Check what works and what doesn't.
3. Write back exactly what you want to fix / change / add.
4. Repeat until it's exactly what you were looking for.

This is true for every AI coding tool — Claude Code, Cursor, Copilot, all of them.

Don't get discouraged if there are bugs or things that don't work on the first round — that's completely normal. Just ask Claude Code in plain language to help you fix the issue, and keep going until it works. Be persistent: like any LLM, Claude Code sometimes hallucinates, so a round or two more may be needed, even when you think you were perfectly clear (and even when it promises it already fixed something and it's working — don't trust it, just test and ask for what needs changing).

Tip: You're allowed (and it's even better) to ask Claude Code how to work with it: "What's the best way to do X?", "Search the web for similar examples", "Explain why you chose this approach."

No — that's how AI on code works, with us and with every other tool (Claude Code, Cursor, Copilot, and the rest). The first version from any model is a starting point, not the final product. No human developer closes a feature in one pass, and neither does AI.

Don't get discouraged. Just explain to Claude Code in plain language what isn't working and what needs fixing, and repeat the cycle until it gets to the right place. Be persistent: even when it promises it fixed something and it's working, test it yourself and ask for changes to whatever still isn't right. This isn't a bug in the process — this is the process.

Like you would to a person — be as specific as possible. Examples from a typical fix round:

• "The 'Save' button doesn't respond when tapped on mobile."
• "The colors in the header are too light, make them darker."
• "Sign-up is failing — check what's wrong and fix it."
• "Add an option to export the table to an Excel file."

You can also ask questions, not just give instructions: "What's the best way to do X?", "Search the web for examples of similar apps", "Explain why you chose this approach", "Is there a simpler solution?". Claude Code will search, explain, and execute — it's both the guide and the one actually doing the work.

Ask Claude Code itself: "I'm stuck — what would you recommend?", "Are there similar apps on the web?", "What options do I have right now?" One of the most overlooked things about working with AI: you can (and should) ask the model how to work with it.

If that doesn't help either, our team is available via the Chat With Support button in the app, the site chat, or email at hello@clickclickclaude.dev. We make every effort to respond to all inquiries as quickly as possible.

One of the most useful features: automatic saving of historical project versions. Every time Claude Code makes a significant change, a new version is created and you can return to it later.

Mainly useful when something went wrong in the last round and you want to go back to the previous state without explaining to Claude Code what to restore. Instead of working hard to fix things, just roll back.

Note: rolling back to a previous version is irreversible. It will delete all changes made after the version you're returning to. Only roll back when you're sure the later version doesn't work for you.

The Run button (and also the Play button at the top) runs the app on your machine, at a private address called localhost. Think of it as a rehearsal stage that only you can see — your real users still see the live site at the project's production address.

Why it's useful:

• See changes immediately, without waiting for deployment.
• Try things safely — nothing here affects real users.
• Catch bugs before anyone else runs into them.

When everything looks good, the changes are pushed to production and the live site updates automatically — no manual deploy needed.

If you were working directly with Claude Code in Current Workspace (without Tasks), you'll need to ask it to continue from where you left off and remind it of the task. Claude Code's chat clears its context on close.

If you were working with Tasks (the recommended approach), the task is saved in Tasks and you can continue from it after reopening the app.

We're working on automatic conversation history saving to make this easier.

To update: close Click Click Claude and reopen it. If a new version is available, an update notification will appear on launch — confirm it, and the latest version installs automatically.

Unlimited use of our app to build whatever you want, including:

• Claude Code wrapper with built-in opinionated practices and skills that make it work more efficiently — fewer broken iterations, fewer unnecessary searches, fewer tokens per task.
• Tasks screen for project task management and running up to 3 agents in parallel.
• Versions screen for rolling back to previous project versions with a single click (quick rollback instead of manual fixes).
• Run screen to run the app locally, seeing changes immediately without waiting for deployment.
• Vault screen for secure management of passwords, tokens, and secret keys, with automatic saving to Vercel and GitHub.
• Full managed environment: hosting (Vercel), database (Supabase), GitHub repo, automated deployment pipeline, and a free generic Vercel subdomain to get started and share with others.

Tokens are separate: you pay them directly at Anthropic's API rates, with no margin from us.

Fair question. Let us be upfront: we're not always cheaper. It very much depends on usage patterns. But in most cases, for our target audience, it does end up significantly cheaper (full breakdown on the Cost page). Here's the mechanics:

First, an important clarification: we're not cheaper because we have a different token rate or a different model. Same official Anthropic API, same prices, no margin. There's no "trick" on the token pricing.

So why does it end up cheaper in most cases?

1. Our wrapper reduces wasted work. The "magic" is the experience we pour into working with Claude Code — opinionated practices that cause fewer searches and fewer broken iterations. Fewer tokens per task, not cheaper tokens.
2. Anthropic's tokens are subsidized, but within windows that actually limit you. Anthropic likely does subsidize tokens in their subscription (they're not transparent about exactly how much), but usage is limited to 5-hour windows, with an additional weekly cap on top. Most users don't come close to fully utilizing these windows simply because it's not comfortable to work that way — no one wants to hit a block after a few minutes of work and be stuck for hours until the next window opens.
3. Non-developer usage pattern. Most people aren't building all day. They want to build occasionally — in the evening, on weekends, when there's an idea, when there's time. Anthropic's limitations hit hardest exactly in this pattern. With us there are no windows — you build at your own pace and pay only for what you consumed.
4. The subscription upgrade trap. When a user keeps hitting the window limit, what most users do is upgrade their subscription. They start at $20/month and jump straight to $100/month. With us it's $7.90 + actual token costs (which in most cases are a one-time cost to build the app + light ongoing maintenance every now and then).

Bottom line: if you build occasionally and not all day, the math almost always works out cheaper with us. If you're a professional developer who consistently maxes out the 5-hour windows on a daily basis, a direct Anthropic subscription may cost less.

Note on transparency: Anthropic says they subsidize tokens, but in practice they don't say exactly how many tokens each user gets at each tier. With us the equation is visible: real API pricing + $7.90 for the environment. That's it.

There isn't and there never will be — not on tokens, not on infrastructure. The common revenue model in AI today is to charge $0.10 for what costs $0.03, call it "credits," and pocket the difference. We chose not to go that route anywhere in the chain.

We make money only from the $7.90/month, nothing else. For every other service (tokens, DB, hosting, domain, deployments), you pay exactly what it costs us. Feel free to compare on the Open Pricing page.

There are limits, and we say so upfront. But they're less rigid than what you'd find going directly to Vercel or Supabase, and it's worth comparing.

An annoying example from Supabase: on the free tier, any database that isn't used for 7 days goes into automatic hibernation. That's a headache — it forces you to come back and deal with infrastructure instead of your product. We don't do that.

When you genuinely exceed the limit, we don't charge arbitrage. We offer an upgrade at the actual cost it charges us from the providers, transparently. The same philosophy we apply to tokens applies to all other infrastructure.

Not quite. The $7.90 gets you the full environment + access to the tool. Token consumption for Opus (or any other Anthropic model) is separate, at Anthropic's own API rates. There's no technical limit on our end, but there is a real token cost that developers need to pay.

Why is it still cheaper in most cases? Full breakdown in the pricing mechanics question.

No and no. No minimum, no long-term commitment. Token top-ups ($20 / $50 / $100) are one-time and don't auto-renew. You can build heavily over a weekend, disappear for a month, come back — the tool bends around your life, not the other way around.

Claude Code stops. To continue developing, go to our site and top up. No surprise charges.

Roughly: a direct Anthropic subscription starts at $20/month and climbs to $100, $200, $300 or more as you hit the 5-hour and weekly window caps and need more capacity. On top of that comes the infrastructure chain — Supabase, Vercel, GitHub — which starts free but with serious use easily climbs to $25–$45/month (exceeding the DB free tier, upgrading Vercel plans, etc.).

With us: $7.90/month fixed for the full environment, and tokens at Anthropic's API rates with no margin. No new accounts to open, no hours spent on setup. We also have basic infrastructure limits, but they're softer than the direct free tiers from providers, and when you exceed them we charge only what we pay the providers — no arbitrage (full details in the infrastructure limits question).

Not currently, and it's worth explaining why.

We're funding Click Click Claude out of our own pockets. No investors, and at this stage we're not looking for any. We could charge much more, or take a margin on tokens (a common revenue model in the vibe coding space). We chose not to go either route.

The $7.90/month covers only the managed environment. Tokens themselves are paid at exactly Anthropic's API rates, with no margin from us. Same for DB, hosting, deployment, and domain. Full breakdown on the Open Pricing page.

We're not ruling out a free tier in the future, but first we need validation: is this problem painful enough that people are willing to pay to solve it? So far the answer has been yes, and that's a sign there's something real here. Once that signal strengthens, it will be much easier to justify opening up a free tier.

Absolutely not. To our knowledge, that would violate Anthropic's terms of service — and that's also not our way. We work with Claude Code via Anthropic's official API, fully by the book, and run it from our platform. No token arbitrage. That's exactly why we built Click Click Claude: to create a proper managed environment for non-developers, not to circumvent anyone's terms of service.

100% yours. Projects live in a GitHub repo we create for you, and your code is fully yours from day one. You can leave Click Click Claude at any time.

On data and domain: in Fully Managed mode they live in our environment, and if you leave, you can migrate to your own accounts (Supabase and Vercel, or alternatives) so the app continues running independently. The domain can also be transferred — or, while you're with us, you can connect your own domain directly to the project through the project page on our site.

No. Never. We don't use your code, prompts, or outputs to train any model — not ours and not anyone else's. Anthropic processes Claude requests under its standard API terms; there's no training signal coming from our side.

In Fully Managed mode: code is on GitHub (in the repo we create), the database is on Supabase (with row-level security), hosting is on Vercel. Each of these is an industry standard — no lock-in, and you can take everything out.

The domain starts as a free Vercel subdomain; you can add a branded domain whenever you like (see the "Technology Under the Hood" section). For those who prefer working on their own existing repo, there's Import mode (details in the next question).

Yes, via Import mode: bring your GitHub repo link and Claude Code works on it directly during sessions. Your code, DB, and deployment stay with you — we don't hold persistent access to your infrastructure, we just serve as a tool that edits the code. More details in the question about getting started options.

Not yet, and we won't pretend otherwise. When real customers need it, we'll start a formal certification process.

In the meantime: secrets encrypted at rest, scoped tokens, least-privilege access, code review on every change, and a clear incident response process. Real security practices — just without a compliance badge.

If your company requires a formal certification to adopt a tool, we're not the right fit yet — but come back to us, we want to know what matters to you.

It depends on the mode you've chosen. Same tool, two different access modes — and you can choose a different mode for each project.

Secrets are encrypted at rest, and tokens are scoped to the minimum permissions needed for operation. Integrations can be managed and revoked from your account settings, and we don't store shared credentials between users.

Next.js, shadcn, Supabase, Vercel — proven defaults chosen for you, so you spend your time building rather than plumbing. An industry-standard stack you can take a serious product anywhere with.

Yes. The opinionated practices we pour into working with Claude Code include writing tests and basic security guidelines as part of the process — not as an afterthought.

On our own infrastructure side: secrets encrypted at rest, Supabase managed with row-level security, scoped tokens, no shared credentials, and code review on every change. More details on the security page.

Automatically. Push to GitHub → build → Vercel → Live. Every change goes through the same standard pipeline that professional developers use — just without you having to set it up yourself.

As soon as the app goes live you get your own URL: a free generic Vercel subdomain — enough to get started and share with early users.

Want a branded domain?

• You can purchase through us: you pay the actual registration price. We don't profit from domain purchases.
• You can import a domain you already bought elsewhere (GoDaddy, Namecheap, Google Domains, any registrar) and connect it to the project.

SSL/TLS is configured automatically via Vercel on all paths.

Tests are written by default, not as an option. For every feature, both unit tests and end-to-end tests are written — so bugs are caught before real users encounter them. This is part of the opinionated practices that are built in automatically, not something you need to remind us about each time.

If you want to expand, change, or remove tests, it's your code — free to edit manually.

Important to know: having tests doesn't mean they'll catch and prevent every bug. Even the world's best developers who write tests can't write tests that cover every bug. If you run into a bug, tell Claude about it and ask it to fix it.

Yes. That's exactly why projects run on Vercel and Supabase rather than an internal server — the infrastructure scales automatically to handle load. No servers to manage, restart, or manually upgrade. This is true for 10 users and true for 10,000.

At the extreme edge (very high traffic, or special requirements like enterprise compliance), you might want more precise control over the infrastructure — but by that point you're no longer the "first app" audience and certainly already know your options.

We wrap Claude Code and run it directly against Anthropic's official API. For people who know how to install, configure, and use Claude Code in a terminal, Click Click Claude will add less meaningful value. For those who don't, Click Click Claude provides:

• Full managed environment (GitHub + DB + hosting), with no manual setup.
• Opinionated practices built in, baked into the work with the model.
• No 5-hour windows — work at your own pace and pay only for what you consumed.

Two main distinctions:

• We run real Claude Code. Many competitors use their own internal harness or different models. Ours is Claude Code's full agent, with its skills and sub-agents.
• Your code, at production level. At the end you have a GitHub repo, a managed database, and a live app on Vercel — an industry-standard stack you can take in any direction, even outside our platform.

OpenAI's Codex works on top of an OpenAI monthly subscription. With us you can start without a monthly subscription from anyone — just $7.90 for the environment + tokens at Anthropic's API rates based on actual usage. Our current environment is built around Claude Code, one of the leading tools in the market for agentic coding.

We may in the future allow choosing between additional models, with the same approach of transparent pricing and no token margin, so users can pick what suits them.

No. OpenRouter is a router layer for models; we're a product layer on top of Claude Code. Not the same category. You can even continue using Claude Code in the terminal — we add an environment on top of it, we don't replace it.

We hope they do improve. Our product is built on the assumption that the model will only get better. What we're building is the environment, not the model: the connection to infrastructure (GitHub, Vercel, Supabase), the Tasks screen for running up to 3 agents in parallel, the Versions screen for quick rollback, the Run screen for local testing, skills that wrap best practices. Even as the model gets smarter, this environment will still need to exist — and those who know how to run it for hundreds of users have the advantage.

It's possible that in the future Anthropic will offer a similar solution for non-technical users. Today they need a bridge, and that's exactly why we built Click Click Claude.

The goal is for anyone with an idea to be able to build it without hiring developers and learning the entire setup chain (repo, DB, auth, deploy). The code lives in GitHub, the data in Supabase, the app runs on Vercel — an industry-standard stack you can take in any direction.

We're building exactly that bridge: from "I have an idea" to "I have a live product," with no lock-in and no miracle promises.

Go to login, add a payment method, and download the app. Inside, describe what you want to build and Claude Code gets started. We've already set up your repo, database, deployment, and domain — everything is ready. Full details in the question about the best way to get started.

No long-term commitment. You can cancel at any time. Your code lives in the GitHub repo we created for you. If you want to keep running the app after cancellation, you can migrate the DB and deployment to your own accounts (Vercel and Supabase, or alternatives) so the app continues running independently.

Yes — a full refund of your first month's payment. Anyone who's not satisfied with the service in the first month just writes to us and gets a full refund of the $7.90. We're here to deliver value, and that's our real test.

Yes. We have a few channels, in order of preference:

• Chat With Support: the button in the app. The fastest way.
• Site chat: if you haven't gone into the app yet, write to us directly from the site.
• Email: hello@clickclickclaude.dev, for less urgent questions.

In all channels our team makes every effort to respond to all inquiries as quickly as possible.

On our site, go to Settings → Billing and click Manage Billing. This takes you to our Stripe payment portal, where you can manage your subscription, update your payment method, and download receipts for all charges.