What Is Claude Code?
Claude Code is Anthropic’s terminal-based AI coding agent. You install it as a command-line tool, give it a prompt describing what you want to build, and it takes over: it plans the project structure, scaffolds the files, installs the right packages, and writes working code directly onto your machine.
There is no browser interface, no drag-and-drop canvas, and no hosted preview link. The output is a codebase on your machine, deployable on any infrastructure you choose.
Who Is Claude Code For?
- Developers who lose time to boilerplate. If you can read and edit TypeScript, Claude Code removes most of the friction between having an idea and having a working project structure with dependencies installed and files properly organized.
- Freelancers and agency owners who code. Claude Code can compress a complex prototype from days to hours, as long as you have the technical ability to evaluate and adjust what it produces.
- Teams already on Claude Pro, Max, or Team plans. Claude Code is included in those plans at no extra charge. If you are paying for one of those tiers already, there is no second subscription to start.
- Solo developers evaluating an unfamiliar stack. Instead of reading documentation for hours, you can watch Claude Code build a working example in a new framework and read the output to understand how the pieces connect.
Claude Code Pros and Cons
- Builds full-stack apps from one prompt
- Asks permission before every terminal command
- Produces real, editable production code files
- Selects appropriate libraries without being asked
- Works within your existing development environment
- Handles complex multi-file projects systematically
- Included in Claude Pro, Max, Team plans
- Requires terminal experience, not for non-coders
- Full builds take fifteen or more minutes
- No visual preview while building
Rating Breakdown
Claude Code is not directly comparable to no-code or low-code GUI app builders. The scores below reflect its performance as a terminal-based AI coding agent for developers, which is the category it belongs to.
Evaluating it on the same scale as a drag-and-drop tool would not give a useful reading for anyone deciding whether to add it to their workflow.
| Feature | Score (Out of 10) | Why the Score |
|---|---|---|
| Ease of Use | 7.0 | Straightforward for developers; the install and interface are clean |
| Features & Functionality | 9.5 | Covers the full stack from auth to payments without guidance |
| Design & Customisation | 8.0 | Generates real CSS and component files; no visual editor |
| Value for Money | 10.0 | Included in paid plans at no extra charge whatsoever |
| Performance & Reliability | 9.5 | Consistent, production-quality output on a complex brief |
| Overall | 9.4 | For developers, Claude Code is close to the best tool in its category. The output quality, library choices, and value are all at the top end. The score accounts for the fact that non-technical users will hit a wall immediately, which is a real limitation even if it is by design. |
Claude Code Features
- Terminal-based agent, runs in your local environment
- Writes and organises multi-file project structures
- Installs and manages packages and dependencies
- Requests approval before each command runs
- Supports Next.js, Supabase, and Stripe natively
- TypeScript and Tailwind CSS support built in
- Slash commands for model switching mid-session
My Honest Claude Code Review: What I Found After Testing It
A lot of people find Claude Code while searching for AI app builders, or land on this page after looking at tools like Lovable, Bolt, Rork AI, or Retool. Before anything else, the distinction needs to be clear: those are AI app builders that give you a graphical interface, a hosted preview, and a point-and-click experience that does not require you to open a terminal.
Claude Code is an AI coding agent. The output is a codebase on your machine. If you are looking for a no-code or low-code GUI tool, Claude Code is not that product, and you will be frustrated before you see a result.
With that said, here is exactly what happened when I ran it against a complex full-stack brief.
Claude Code Is a Coding Agent, Not an App Builder
The terminology matters because it changes what success looks like. With a GUI app builder, success is seeing a live preview in a browser. With Claude Code, success is a working codebase on your machine that you then run, test, and deploy yourself.
Claude Code sits in a category alongside tools like Aider, Devin, and Cursor’s agent mode. The difference from those tools is that Claude Code is a standalone terminal application made by the same company that builds the underlying model. There is no third-party integration layer between you and the AI.
If you are a developer evaluating AI coding tools, this positioning matters: you get direct access to Anthropic’s models, permission controls on every command, and output that lands in your file system rather than a proprietary platform.
Setting Up Takes Under Five Minutes, But You Need a Paid Plan
There are four ways to get Claude Code running. Each suits a different starting point.
| Method | Requirements | How to Start |
|---|---|---|
| Native installer | None (no Node needed) | curl -fsSL https://claude.ai/install.sh | bash |
| npm package | Node 18+ | npm install -g @anthropic-ai/claude-code |
| VS Code extension | VS Code installed | Install from the VS Code marketplace |
| JetBrains plugin | IntelliJ, WebStorm, etc. | Install from the JetBrains marketplace |
After installation, run claude –version to confirm it worked. If the command is not found, close and reopen your terminal or run source ~/.bashrc first.
Authentication opens a browser for OAuth login. Use the same account you have on Claude.ai.
Starting a session inside your project folder looks like this:
mkdir my-project
cd my-project
git init
claude
This drops you into an interactive session inside that folder.
The plan requirement is the non-negotiable part. The free Claude.ai tier does not include Claude Code. You need a paid Claude Pro, Max, or Team plan, or an active Anthropic API Console account. There is no way around this. Anyone testing Claude Code should check their plan status before going further.
From Prompt to Build Plan in Under Ten Seconds
I tested Claude Code using the same prompt I have used across multiple AI app builder tests: a full-stack Client Portal and Invoicing App for freelancers and small agencies. The brief covered:
- A professional landing page with hero section, features section, three-tier pricing, and a call-to-action
- User roles (Owners, Members, Clients) with different permissions and onboarding flows
- A multi-tenant dashboard showing KPIs: revenue, active clients, outstanding invoices, hours tracked
- Client and project management
- Time tracking tied to projects
- Invoicing with PDF preview and export, plus the ability to send invoices to clients
- Stripe integration for subscriptions and one-time invoice payments
- A client portal where clients can log in and view invoices, payment history, and project status
- Professional blue as the primary colour, card-based layouts, subtle animations
- Supabase backend with email/password and Google OAuth, multi-tenancy, file storage, and transactional email
Claude Code responded within ten seconds: “I’ll build this full-stack app systematically. Let me start by checking the current directory state, then plan and implement the entire application.”
That was the only acknowledgment before it started running commands. No framework question. No schema discussion. No confirmation about whether to use server-side or client-side Supabase. It read the brief and started executing.
The session header confirmed the setup: Sonnet 4.6 on Claude Pro. A banner at the top of the session noted that Fable 5, Anthropic’s newest model for complex and long-running work, was available and switchable at any point using the /model slash command. The same banner displayed: “Included in your plan limits until Jun 22, then switch to usage credits to continue.” Claude Code usage counts against your monthly plan quota.
Update (June 2026): Anthropic’s new Claude Fable 5 model was temporarily suspended worldwide following a U.S. export-control directive over national security concerns. Anthropic has since indicated the suspension is temporary, and Fable 5 has begun reappearing in the model selector for some Claude users as access is gradually restored.
Every Command Needs Your Approval Before It Runs
Before executing anything on your machine, Claude Code pauses and presents an approval prompt showing the exact command, a plain-English description of what it does, and three options:
- Yes (approve once; you will be asked again next time)
- Yes, and don’t ask again for [this command pattern] (auto-approve similar commands going forward)
- No (block the command; Claude Code tries a different approach)
The prompts appeared in this order during my session:
- Directory check: ls -la /home/nova/invoicepro-claude-code/ && node –version && npm –version
- Next.js initialisation: npx create-next-app@latest . –typescript –tailwind –eslint –app –src-dir=false –import-alias=”@/*” –yes 2>&1 | tail -20
- Core dependency install: npm install @supabase/supabase-js @supabase/ssr stripe… (18 packages)
- Library version checks: separate node commands to verify lucide-react and framer-motion
- File writes: “Do you want to overwrite globals.css?” with an option to allow all file edits for the rest of the session using Shift+Tab
The distinction between bash command approval and file overwrite approval is deliberate. Running a command and overwriting a file you may have already edited are different levels of consequence, and the tool treats them differently.
Useful shortcuts within a session:
| Command | What It Does |
|---|---|
| /model | Switch the active model (e.g., move to Fable 5) |
| /btw [question] | Ask a side question without interrupting the active build |
| /status | Check current session status and plan usage |
| Shift+Tab | Allow all file edits for the session without per-file prompts |
| Ctrl+B | Run the current command in the background |
| Ctrl+O | Expand truncated output to see the full file or log |
The Build Timeline: Dependencies, Files, and a Running Token Count
Once the setup approvals were cleared, the build moved through distinct phases. Here is what the terminal showed at each stage:
| Time Mark | Status Message | What Was Happening |
|---|---|---|
| 0:00 | “Booping… (8s · 421 tokens thinking)” | Processing the prompt and planning |
| 0:30 | Directory check complete | Clean repo confirmed; Next.js init started |
| 1:30 | “Running… (13s · timeout 2m)” | Next.js 14 project scaffolding underway |
| 2:30 | “Beaming… (32s · 1.3k tokens)” | Waiting for npm install to complete |
| 4:00 | Library version checks | lucide-react and framer-motion versions verified |
| 5:33 | “Enchanting… (5m 33s · 11.4k tokens)” | supabase/server.ts and middleware.ts written |
| 15:31 | “Enchanting… (15m 31s · 62.8k tokens)” | time-tracking page at 432 lines; invoicing section starting |
The dependency install covered 18 packages in one command, grouped below by what they handle:
| Category | Packages |
|---|---|
| Database and auth | @supabase/supabase-js, @supabase/ssr |
| Payments | stripe, @stripe/stripe-js, @stripe/react-stripe-js |
| PDF generation | @react-pdf/renderer |
| Charts | recharts |
| Animation | framer-motion |
| Icons | lucide-react |
| Date handling | date-fns |
| Forms and validation | react-hook-form, zod, @hookform/resolvers |
| Styling utilities | clsx, tailwind-merge |
| Notifications | sonner |
| Theme | next-themes |
| resend |
After all packages were confirmed installed, Claude Code announced: “All dependencies installed. Now I’ll build the entire application systematically. Starting with configuration, then each major section.” It then read five files, listed one directory, and started writing.
At the 15-minute mark, the session was still running. The time-tracking page alone was 432 lines of TypeScript. The terminal showed the next task: “Now building the invoices section with the invoice form and PDF preview.” A full build of a project this complex will run past thirty minutes, possibly longer.
The Library Choices Reflect Production Expertise, Not Tutorial Defaults
The most telling signal in any AI coding tool is not whether it produces code but whether the code reflects real knowledge of the stack. Two things stood out immediately when I reviewed the generated files.
The Supabase choice: Claude Code installed @supabase/ssr rather than the standard client-side Supabase SDK. For a Next.js 14 App Router project, this is the correct decision. The client-side SDK does not work properly in server components and creates session management bugs that are not immediately obvious. Claude Code made the right call without being asked.
The form validation stack: It used zod paired with @hookform/resolvers. This is standard in production Next.js work, not what a tutorial example would reach for.
The files written confirmed this at code level:
lib/supabase/server.ts (27 lines):
import { createServerClient } from “@supabase/ssr”;
import { cookies } from “next/headers”;
export async function createClient() {
const cookieStore = await cookies();
return createServerClient(
process.env.NEXT_PUBLIC_SUPABASE_URL!,
process.env.NEXT_PUBLIC_SUPABASE_ANON_KEY!,
{ … }
);
}
middleware.ts (57 lines) used createServerClient for session refresh and protected route logic with NextResponse and NextRequest from Next.js server. This is how production Supabase authentication is meant to be wired in a Next.js deployment.
app/(dashboard)/time-tracking/page.tsx (432 lines) opened with “use client” at the top and imported from the project’s own UI component library rather than directly from a UI package. That tells you Claude Code had already built the component library by that point in the session.
The CSS choices also held up. The globals.css additions included custom keyframe animations (spin-slow, animate-fade-in, animate-slide-in-right) with timing that matches the “subtle animations” requirement in the original brief.
After the Build: What You Still Need to Handle
Claude Code produces the codebase. Getting the application live requires several steps on your end. None of these are complicated for a developer, but readers should know about them before starting.
Environment variables to configure:
| Variable | Where to Get It |
|---|---|
| NEXT_PUBLIC_SUPABASE_URL | Your Supabase project settings |
| NEXT_PUBLIC_SUPABASE_ANON_KEY | Your Supabase project settings |
| SUPABASE_SERVICE_ROLE_KEY | Supabase project settings (server-side only) |
| STRIPE_SECRET_KEY | Stripe dashboard |
| NEXT_PUBLIC_STRIPE_PUBLISHABLE_KEY | Stripe dashboard |
| RESEND_API_KEY | Resend dashboard |
Steps before the app will run:
- Create a Supabase project and run the generated SQL migrations
- Set up Google OAuth credentials in the Supabase Auth settings
- Create a Stripe account and configure your products and pricing
- Set up a Resend account for transactional email
- Create a .env.local file and add all variables listed above
- Run npm run dev to start the development server
What Claude Code handles for you:
- Full file structure and routing
- All component code
- All API routes and server actions
- Authentication flow code
- Multi-tenant data isolation logic
- PDF generation setup
- Stripe payment flow code
- Email notification code
The split is clear: Claude Code writes the code; you supply the external service credentials.
Overall Verdict on Claude Code
Claude Code earns its 9.4 by doing the thing developers actually need: writing production-grade code that does not have to be thrown away or rebuilt before it can ship.
The test project covered a demanding brief, and at fifteen minutes in, what had been generated was real working code with correct architecture decisions and appropriate library choices. That alone separates Claude Code from most tools in its category.
Where it genuinely earns its keep:
- Full project scaffolding from a detailed brief (the use case tested here)
- Adding features to an existing codebase (point it at an existing repo and describe what to add)
- Debugging specific errors (paste the error, describe the file structure, let it investigate)
- Writing and fixing tests (it can run your test suite, read the failures, and fix them in a loop)
- Refactoring a specific module or file without touching the rest of the project
- Explaining unfamiliar code in a codebase you just inherited
- Running in the background via Ctrl+B while you work on something else, checking back when it finishes
What the test did not show but you need to know:
- MCP server support. Claude Code connects to Model Context Protocol servers, which means you can give it access to external databases, APIs, documentation systems, and internal tools. A Claude Code session can query your production schema, read your internal documentation, and write code that already fits your actual data model. For teams, this matters more than any single feature.
- Git awareness. Point Claude Code at a repository, and it reads the existing codebase before it starts writing. Running git init before starting a session is not just housekeeping. Claude Code uses git status and file diffs to understand what already exists, which means it will not overwrite things it should not touch.
- Token consumption is real. At fifteen minutes into the test session, the running total was 62.8k tokens. Complex builds move through tokens fast. On Claude Pro with standard monthly limits, a few large builds can account for a meaningful share of your quota. Claude Max or a Console account makes more sense for anyone running multiple builds per week.
- The /compact command. In long sessions, Claude Code accumulates conversation history that consumes tokens and can slow the session down. Running /compact compresses the history while preserving the important parts. Worth knowing before you start any build that will run past twenty minutes.
- Headless mode. Claude Code can run non-interactively with the –print flag, making it usable in CI/CD pipelines and automation scripts. This is not something most individual users will need on day one, but it means Claude Code can be embedded into team workflows rather than sitting as a standalone developer tool.
- Create a git branch before each session. Claude Code makes fast decisions and commits to them. If you start a session without branching first and the architecture goes in a direction you did not want, undoing it is more work than branching would have been.
Who should use it:
- Developers who want to skip the parts of their work they find tedious, specifically scaffolding, dependency wiring, and boilerplate
- Teams that can write a thorough brief and evaluate the output against it
- Anyone on Claude Pro, Max, or Team who is not using it yet (the cost case is already made)
Who should look elsewhere:
- Non-developers who cannot read the code that comes out
- Anyone who needs a shareable, hosted preview without opening a terminal
- Anyone expecting a five-minute result from a complex brief
- Developers who want to decide every architectural choice upfront before any code is written (Claude Code decides fast and moving backward takes extra prompting)
Claude Code Pricing and Plans
Claude Code is not sold as a standalone subscription. It is included in Claude Pro, Max, and Team plans.
What each plan means for Claude Code users:
- Free: Claude Code is not available. There is no workaround.
- Claude Pro: Includes Claude Code. Covers typical usage for a developer running a few builds per week. Plan limits apply; heavy sessions can push you toward usage credits before the month ends.
- Claude Max: Includes Claude Code with significantly more monthly usage (5x or 20x the Pro allocation). Best for anyone running multiple large builds per month.
- Claude Team: Includes Claude Code for all seats. Suited for engineering teams who want the agent available across the organisation.
- Anthropic Console (API account): Billed per token rather than a flat monthly rate. Best for developers who build sporadically but intensively, since you pay for what you use rather than a fixed monthly amount.
A note on usage limits: Claude Code sessions count against your plan’s monthly quota, not a separate allocation. As shown during my session (the banner read “Included in your plan limits until Jun 22, then switch to usage credits to continue”), a complex build can consume a meaningful portion of a monthly limit. If you are close to your cap and you start a large project, the session may roll into usage credits before it finishes.
Refund policy: Payments on standard plans are non-refundable by default under Anthropic’s Terms of Service. The exception is the EEA and UK, where a 14-day cancellation right applies. Refund requests go through the account’s support messenger under “Get help” in your account settings.
Payment methods: Credit card for individual plans. Team and Enterprise plans add ACH and invoicing options with monthly or annual billing cycles.
Alternatives to Claude Code
The closest direct alternative is Cursor. Cursor is an AI-powered code editor with an agent mode that can read your codebase, write files, and run terminal commands, which covers much the same ground as Claude Code. The primary difference is that Cursor is IDE-first: you get a graphical editor alongside the agent, which lets you review and adjust output in real time rather than waiting for a full build to complete before you can evaluate anything.
A reader would choose Cursor over Claude Code if they want AI-assisted coding inside a visual editor, prefer seeing changes as they happen, or are already working in VS Code and want to stay in that environment without opening a separate terminal window.
| Feature | Claude Code | Cursor |
|---|---|---|
| Ease of Use | Terminal-only, developer-focused | IDE-based, more approachable |
| Best For | Full project builds from a single prompt | Iterative coding with real-time AI edits |
| Backend and Data | Works with any stack you specify | Works with any stack |
| Design Flexibility | Generates CSS and components; no visual editor | Visual editor with AI overlay |
| Pricing Model | Included in Claude Pro, Max, Team plans | Separate subscription required |
Final Verdict: Is Claude Code Worth It?
Claude Code earns its place in a developer’s toolkit for two reasons. First, the output quality is genuine. The library choices I saw during my test reflected real understanding of the stack, and the code produced at the fifteen-minute mark was not scaffolding but working files a developer could build on. Second, the value case is simple: if you are already on Claude Pro, Max, or Team, Claude Code costs you nothing extra.
The tool is not for every reader who lands on this page. If you do not write code, you will not be able to use it. The terminal is not optional, and neither is the ability to read what comes out. Anyone expecting the five-minute turnaround of a browser-based app builder will find the experience frustrating before they see a result.
If you are a developer on a paid Claude plan and you have not tried Claude Code yet, try it this week. Start with a project you know well enough to evaluate the output. The learning curve is low if you are already comfortable with a terminal, and the output on a well-written prompt is better than most alternatives in the same category.
