DEV Community: BrainGrid

Claude Code Pricing 2026: Pro vs Max vs Team (Updated June)

Nico Acosta — Tue, 07 Jul 2026 11:12:38 +0000

AI coding assistants like Claude Code, ChatGPT, Cursor, and Windsurf are changing how founders ship software. These tools accelerate development for experienced engineers and enable non-technical SaaS founders to build working prototypes without hiring a dev team.

But how much does it all cost? How much will a team spend on tools like Claude Code, and how can they prevent bill shock at the end of the month from overages? Read on to understand how to use Claude Code efficiently and avoid burning tokens.

How Much Does Claude Code Cost? Quick Overview

Visiting Claude.ai lets you chat with Claude's latest models.

But free Claude access does NOT include Claude Code. Access to Claude Code requires a monthly subscription.

Plan	Cost	Claude Code Access	Best For
Pro	$20/mo	✓ Full access	Daily coding, solo founders
Max 5x	$100/mo	✓ Extended limits	Heavy users, complex projects
Max 20x	$200/mo	✓ Maximum capacity	Power users, all-day coding
Team (standard seat)	$25/user/mo ($20 annually)	✗ Not included	Collaboration, research, admin
Team (premium seat)	$125/user/mo ($100 annually)	✓ Plus Cowork	Organizations, dev teams
API-only	Pay-per-token	Via terminal	Custom integrations

The Team plan trap: standard Team seats do NOT include Claude Code. If your team signed up to build, the developers need premium seats. Full decision guide in our Claude Pro vs Team vs Max breakdown.

Note that Anthropic offers yearly discounts on annual subscriptions - Claude Code Pro is $17/mo (15% savings) when purchased annually.

Each Claude Code subscription includes session limits—a maximum number of prompts you can send within a rolling 5-hour window. Claude Code Pro subscribers can expect a maximum 45 messages per 5-hour window. However, coding prompts consume more tokens than simple chat queries, so you'll realistically get 10-40 prompts per window.

Here's the worst feeling: You're in flow state, shipping a critical feature, and Claude Code says "You've reached your usage limit. Try again in 3 hours." Your momentum is gone. Your code progress halts for hours.

Why this matters: If you're racing to a demo, investor meeting, or launch deadline, losing 2-3 hours could mean missing your target.

You can turn on extra usage in your settings to keep Claude Code going. Set a monthly maximum you're comfortable with. Anthropic's documentation reports the average cost is $6/day, with 90% of developers under $12/day.

Any extra usage is paid at the API token pricing:

API Token Pricing

Model	Input (per 1M tokens)	Output (per 1M tokens)
Haiku 4.5	$1	$5
Sonnet 4.6	$3	$15
Opus 4.8	$5	$25
Fable 5	$10	$50

Claude Pro vs Max: Which Plan Should You Choose?

The Max plans cost more but include significantly more token capacity. Claude Max 5x costs $100/month and includes 5x the tokens of Pro. Claude Max 20x gives you 20x the tokens for $200/month.

For regular daily coding, troubleshooting, and planning, Claude Pro is sufficient. You may find a few days of heavy coding leads to extra usage charges.

When to upgrade to Max 5x: If you're hitting Pro's limits daily and spending $4+ on extra usage, Max 5x becomes cost-effective. Here's the math:

$4/day × 22 working days = $88 in overages
Add your $20 Pro subscription = $108/month total
Max 5x costs $100/month flat with 5x the capacity

If your overages consistently exceed $80/month, Max 5x saves money and removes the usage anxiety.

Claude Code Teams and Enterprise: When Do You Need Them?

Claude Code on the Team plan requires a premium seat at $125/month per developer ($100/month billed annually). The plan has a 5-seat minimum across seat types, with standard seats at $25/month ($20 annually) for teammates who collaborate but do not code. Five premium seats run $625/month; a mixed team of two developers on premium seats plus three standard seats is about $325/month.

Premium seats carry roughly 6.25x Pro's usage per session (5x a standard seat), slightly above Max 5x. But the real benefit is governance: your data is excluded from model training, Model Context Protocol (MCP) servers are configured at the team level, so when a developer leaves, you automatically revoke their access to internal databases and tooling, and Team provides centralized billing and usage auditing.

The decision framework:

Two founders building a product? Use two individual accounts; the 5-seat minimum makes Team expensive for you.
Growing past 5 developers? Security, permissioning, and data controls become critical. Team makes sense, with premium seats for the builders only.
Need SOC2 compliance or audit trails? Team is the path forward, and Enterprise ($20/seat plus API-rate usage) adds HIPAA options and SCIM.

For the full plan-choice walkthrough, including when individual Max plans beat Team seats, see Claude Pro vs Team vs Max.

How to Reduce Claude Code Costs: Practical Efficiency Strategies

Now that you know the pricing tiers, let's talk about the real cost lever: how efficiently you use tokens.

Every question, code review, and bug fix burns tokens. But you can cut how many tokens each query consumes. These strategies can reduce your bill by 50-80%.

Use `/clear` between tasks

The /clear command tells Claude Code to forget the current conversation context. Say you're squashing bugs: after fixing a frontend CSS issue, you jump to a backend database query. There's no need for Claude to keep the CSS conversation in memory. Clear it out for better results and fewer tokens.

When to /clear: Switching between unrelated files, moving from frontend to backend, or jumping from feature work to bug fixes. If Claude's suggestions start referencing the wrong context, you waited too long.

Use `/compact` to summarize the conversation

When building a feature over several iterations, every code snippet gets shared every time. The context window grows larger, meaning more tokens per question.

The /compact command tells Claude Code to summarize the current chat and start fresh with the "Cliff's Notes" version. The conversation continues with all pertinent details but uses a fraction of the tokens.

Rule of thumb: Use /compact after 10-15 messages or when /cost shows over 5M tokens in your session. You'll know you waited too long when Claude starts repeating itself or missing context from earlier.

Check your usage with `/cost`

The /cost slash command shows token usage for your current session. Use this to understand your usage patterns and identify which tasks burn the most tokens.

Configure `.claudeignore`

Just like .gitignore tells Git which files to skip, .claudeignore tells Claude what files to ignore when analyzing your codebase. Are you accidentally sending your entire node_modules folder to Claude with every prompt? That's 50-90% wasted tokens.

Action: Create .claudeignore in your project root with these lines:

.gitignore
node_modules/
.next/
build/
dist/
*.log
.env*
.git/

Run /cost before and after to verify the reduction.

Model Selection Strategy

Different Claude models have different costs. Match the model to the task:

Task Type	Model	Why
Autocomplete, simple edits	Haiku 4.5	Fastest, cheapest
Feature implementation	Sonnet 4.6	Best balance
Complex debugging	Sonnet 4.6	Usually sufficient
Architecture decisions	Opus 4.8	Worth the premium
Critical production code	Opus 4.8	When it matters most

The rule: Sonnet handles 80% of your work. Reserve Opus for complex reasoning tasks where Sonnet gets stuck. This alone can reduce token costs by 30-40%.

When to break the rule: If Haiku gives buggy code twice, jump straight to Sonnet. Don't burn three cheap iterations when one good Sonnet response costs less.

The Biggest Token Saver: Spec-Driven Development

All the tactics above (clearing, compacting, model switching) save 10-40% on tokens. But they miss the real problem: rebuilding the same feature over and over because the requirements weren't clear. Spec-driven development solves this.

The expensive way:

Prompt: "Build user authentication"
Claude builds it (5,000 tokens)
You: "Actually, I need email verification"
Claude rebuilds (6,000 tokens)
You: "And password reset"
Claude rebuilds again (7,000 tokens)

Result: 18,000 tokens, 3 rebuilds, one frustrated afternoon.

Spec-first workflow:

Write a clear requirement before coding
Break it into specific tasks
Implement each task with Claude understanding the full context

With the right prompt built from a clear specification, you can build the feature correctly the first time. That's 60-80% token savings.

BrainGrid formalizes this workflow, turning vague ideas into structured specs that Claude can implement in one pass. Give BrainGrid a prompt of what you'd like to build, and BrainGrid asks implementation questions and feature questions, just like a product manager fleshing out the details of what should be built. A requirements document is created, which you can use to generate a list of tasks.

Connecting BrainGrid to Claude Code allows Claude Code to read the requirements and tasks, then implement them directly from the command line. For the full setup, see our Claude Code MCP servers guide.

Spec-driven development ensures the prompts provided to Claude Code are complete and will build the expected feature the first time. Eliminate the iteration rabbit hole to save a huge percentage of token usage.

Is Claude Code Worth It? The Solo Founder's Decision Framework

If you value your time at $50/hour, Claude Code needs to save you 24 minutes per month to break even. That's one debugging session.

For a solo founder shipping products, a $20 Claude Code Pro account is worth it if it saves one hour of debugging. Any additional time savings from feature coding, prototyping, or writing tests is bonus ROI.

If Claude Code helps you shave 10-30% from each dev cycle (or increase output per cycle by 10-30%), that's $20 very well spent.

Maximize your $20/month: Pair Claude Code with BrainGrid to turn ideas into shippable specs in minutes, or integrate with other agentic tools like Cursor to further accelerate how quickly you and your team ship.

Frequently Asked Questions

How much does Claude Code cost?

Claude Code Pro is $20/month ($17/month when paid yearly). Claude Code Max ranges from $100-200/month for power users. On the Team plan, Claude Code requires a premium seat at $125/month per developer ($100/month billed annually).

Is Claude Code free?

No. A free Claude account allows chat on the web, but no access to Claude Code. You need a paid subscription.

What's the difference between Claude Pro and Max?

Claude Pro is $20/month. Claude Max starts at $100/month and includes 5x the token capacity. Upgrade trigger: If you're spending $80+/month on overages, Max 5x is more cost-effective.

Why is Claude Code using so many tokens?

When iterating on a problem, Claude Code processes the full conversation context with each response. Long conversations with lots of code snippets burn tokens fast. Use /clear between tasks and /compact during long sessions to reduce usage.

How do I reduce Claude Code costs?

The biggest lever is reducing iterations. Great prompts from tools like BrainGrid's spec-driven development ensure you build features correctly the first time. Fewer iterations = fewer tokens = lower costs.

Is Claude Code worth it?

If it saves you one hour of debugging per month, you've broken even (assuming your time is worth $20+/hour). Most founders report saving 5-10 hours monthly. Try Pro for 30 days and track time saved vs. rate limit waits.

Claude Code vs Cursor: which is cheaper?

Both have a $20/month basic plan. Cursor includes an IDE and routes queries to different LLMs automatically. Claude Code gives you direct access to Claude's full model lineup. For most founders, pick based on workflow preference, not price. See our detailed Cursor pricing breakdown for more.

What are Claude Code rate limits?

Claude Code has a 5-hour rolling window for token usage. Hit the limit and you'll see "Try again in X hours." Avoid surprises: Enable extra usage with a monthly cap (Settings > Billing). If you're regularly hitting limits, consider Max 5x.

Originally published on the BrainGrid blog.

Cursor Pricing 2026: Free vs Pro vs Ultra — Which Plan?

Nico Acosta — Mon, 06 Jul 2026 11:12:17 +0000

Cursor is a popular Agentic AI coding tool, helping developers improve productivity, and even helping SaaS founders with no coding background build fully functional systems. Unlike other agentic tools like Copilot or Claude Code which are primarily editor extensions, Cursor is a standalone IDE (Integrated Development Environment) that replaces the need for using VS Code (it is actually a fork of VS Code). It melds a native coding experience with a AI-first conversational coding solution.

Agentic AI tools like Cursor speed development and improve developer performance. The LLM agents inside Cursor do not just blindly add code to your repository. When prompted with a code change, the AI Agents read your existing code, write code that fits into your existing codebase - matching styles and reading across files and modules to ensure that the generated code is compatible with the entire repository.

But, how much does such an AI tool cost? While the Cursor AI pricing page provides the basic details, this post aims to break down the available plans so that your team can determine the price point most appropriate for your usage needs and help you understand when you need to upgrade to a more advanced plan.

What Cursor Brings to the Table

To understand the pricing of Cursor, it is important to understand the features that Cursor brings to your development team. As previously mentioned, Cursor is a full-fledged IDE that developers can use for coding. The AI Agents inside Cursor have many features that improve coding workflows:

Full repository awareness: Code analysis isn't limited to a single function or file—Cursor understands your full repository and how changes affect other files, modules, and dependencies.
MCP integrations: Cursor has native Model Context Protocol support to pull context from outside your repo—APIs, documentation, databases, or internal tools.
Multiple file changes: Plans and applies multi-file diffs when creating code.
Natural language: Build code using plain English prompts.
File safety: Git-based file safety makes it easy to review, accept, reject, or roll back changes.

No matter the pricing tier - these features are included with your Cursor subscription. The major differences between the Cursor pricing plans comes from how much Agentic access is provided, but we will also dig into the subtle differences.

We'll kick off our review of plans designed for a single developer: what Cursor calls "Individual plans." These plans are best for a founder or developer coding alone on a project.

Hobby Tier: Starting with Cursor

Never used Cursor? The free "Hobby" tier lets you test the tool and see if Cursor's workflows fit your existing processes. Being free, the Hobby plan provides very limited access:

Tab completions: Cursor's coding autocomplete feature lets you build faster - by tabbing the suggested autocompletes from Cursor.
Agent requests: Chat with Cursor's agents to code or debug your code.

This is a great way to experiment with Cursor before buying a paid plan. As you might expect, the number of Agent requests is small—you may complete one feature (or only part of one) before running out of credits and being prompted to upgrade.

Get stuck mid-feature on the Hobby tier? You can activate a 7-day free Pro trial to help you complete your project.

Pro ($20/month): The Sweet Spot for Most Founders

The Pro plan is Cursor's most popular tier: at $20/month for one user, it's an easy entry point that won't break the bank. You get everything in Hobby, plus higher limits:

Unlimited tab completions: Tab completions are virtually unlimited on the Pro plan.
Extended limits on Agent Requests: While not unlimited, the number of Agentic Requests is much higher.

The Pro plan also introduces the ability to run Background Agents. You can ask Cursor to work on a task in the background, while you continue to use the Agent in your current coding. The Background agent works asynchronously to the developer's work - coming back only when it has an answer, or has a clarifying question.

The number of Agent Requests and Background Agents provided in Cursor's Pro plan are provided quantitatively. When an Agentic call is made, Cursor breaks the task up for different agents, and utilizes common LLMs (OpenAI, Gemini and Claude are commonly used) to 'solve' the problem. The Pro plan includes a fixed monthly allowance of AI compute, roughly equivalent to what Cursor internally budgets for a $20/month user. Token usage is abstracted away from the developer—there is no visible token counting, only usage-based limits.

Should a developer utilize all of the Agent requests allocated in a month, there are two options: the team can either block overage charges, and advanced agent features pause or degrade until the next billing cycle, or the team can cap the amount of overage charges that can be accrued in the month.

Pro+ ($60/month) and Ultra ($200/month): For Heavy Users

Once developers begin using Cursor, they may find that they become heavy users, and they reach the limits of the Pro plan. The Pro+ and Ultra plans are built for these developers.

For heavy users of Cursor, the Pro+ plan (at $60 per month) provides everything in the Pro plan, but provides 3x more usage with the top models - allowing for more background tasks, and Agentic problem solving.

For extremely heavy users, Cursor's Ultra plan provides 20x the usage of the Pro plan - for $200 a month.

Team and Enterprise plans

For side projects or solo development, Individual plans make sense—you know your usage and can pick accordingly. But as your team grows, managing individual plans becomes a bookkeeping nightmare and introduces security concerns.

This is where Cursor's team and enterprise plans fit in.

Cursor's team plan costs $40 per month per user, fitting between Pro and Pro+ individual accounts.

Beyond centralized billing and easy team member management, the major advantage is improved data isolation and privacy controls. Prompts and code analyzed on a Teams account are not used to train models.

The biggest privacy win? MCP access is controlled at the team level. Proprietary data from MCPs stays managed by your organization—it can't leak to individual accounts when developers come and go.

For teams with stricter privacy requirements, the Enterprise plan adds region-specific data handling (data stays in your country/region), audit logging, and deeper admin visibility. Enterprise pricing isn't published—you'll need to work with Cursor's sales team for a custom contract.

Addons: Bugbot

Cursor offers Bugbot - a product that scans every PR on Github for potential bugs. It acts like a senior dev that reviews the code, looking for bugs in code being submitted for review. The Pro and Teams versions of Bugbot cost $40 per user per month, in addition to the Cursor subscription. While this may seem expensive at first, Bugbot delivers the highest ROI for teams with junior or mid-level developers by catching common bugs before senior engineers need to review the code. It acts as a first-pass reviewer, reducing review noise and protecting senior developer time.

Further extending Cursor: BrainGrid's spec driven development

Cursor's Agentic coding AI raises the bar and improves productivity of development teams. But all developers who use AI know about falling into 'rabbit holes' where the AI is just not interpreting the prompts well, and hours are spent getting the AI back on track and to have it stop making similar mistakes over and over.

Many times, features are built at the prompt with little forethought or planning. As the feature evolves, so too do the prompts and the underlying code.

In traditional development processes, Product Managers work with the stakeholders to plan what the feature looks like, what it should (and should not) do, and build a roadmap of how the feature will evolve. BrainGrid acts as a product-management layer for AI coding workflows - helping developers take ideas for features, and building requirements around the feature. BrainGrid asks clarifying questions to help the product owner better understand what is being built, and what is out of scope. This spec driven development leads to the creation of a requirements document that describes the scope of the feature and what is going to be built. The team can analyze and make changes.

Once the requirements document is approved, BrainGrid creates tasks with prompts that can be fed directly into Cursor. The prompts are highly detailed, which means that there are fewer back and forth iterations with the Agentic AI to actually build the feature. See an example of feature building with BrainGrid and Cursor in our Windsurf vs. Cursor comparison.

Connecting the BrainGrid MCP into Cursor ensures that features are better understood and fleshed out - instead of just building at the prompt. This results in faster development, fewer rabbit holes, and higher productivity.

Starting at $10/month/user (to $75/month/user for enterprises), BrainGrid's product driven specifications gives Cursor additional superpowers, further accelerating your team's development productivity.

Wrapping up

Cursor's paid plans start at $20/month and scale to $200/month for the Ultra tier. For development teams, the Team and Enterprise plans simplify billing while adding privacy and security controls. And for teams going all-in with agentic coding, spec-driven development tools like BrainGrid help you build better prompts—leading to focused code and fewer AI rabbit holes.

To learn more, visit Cursor.ai or explore spec-driven development at BrainGrid.ai.

FAQ

How much does Cursor Team cost?

Cursor Team starts at $40/month per user.

How costly is Cursor?

Plan	Price	Best For
Hobby	Free	Testing Cursor before committing
Pro	$20/mo	Solo founders shipping MVPs
Pro+	$60/mo	Heavy daily users hitting Pro limits
Ultra	$200/mo	Full-time AI-assisted development
Team	$40/user/mo	Startups with 2+ developers
Enterprise	Custom	Regulated industries, large orgs

Is Cursor AI free or paid?

There's a free Hobby tier, but paid plans start at $20/month.

Is Cursor better than Copilot?

They're different tools. Copilot generates code snippets; Cursor understands your full repository and builds code that fits your existing codebase.

Do you need a subscription for Cursor?

Yes, though the Hobby tier is free for testing.

Is Cursor's free plan good?

It's like a taste of ice cream—enough to evaluate, but most real-world development requires a paid plan.

How much do different models cost in Cursor?

By default, Cursor uses Auto mode, that uses internal tooling to pick the bets agent for a given task. This can be overridden, and developers can choose specific Agents (like Opus 4.5, Sonnet 4.5, ChatGPT 5.2, and Gemini 3) for all queries. Cursor has published cost per million tokens for many of the most popular and powerful models in their documentation

Originally published on the BrainGrid blog.

Ralph Wiggum Plugin for Claude Code: Autonomous Coding Guide

Nico Acosta — Sun, 05 Jul 2026 11:12:51 +0000

You know that feeling when you're three hours deep into fixing tests, and each fix breaks something else?

What if you could just walk away? Describe what you want, go grab dinner, and come back to working code?

That's Ralph Wiggum.

Why "Ralph Wiggum"?

Remember Ralph Wiggum from The Simpsons? The kid who keeps trying despite failing spectacularly every single time?

That's exactly what this plugin does. It fails, learns, tries again, and keeps going until it succeeds. No complaints. No giving up. Just persistent iteration until the job is done.

The creator, Geoffrey Huntley, captured it perfectly: "Ralph is a Bash loop."

while :; do cat PROMPT.md | claude ; done

Keep running the same prompt until it works. That's Ralph.

What is the Ralph Wiggum Plugin for Claude Code?

The Ralph Wiggum plugin is Claude Code's official plugin that enables autonomous loops—letting AI work on its own for hours without you watching.

Normal Claude Code: You ask → It does → You check → You ask again → Repeat.

Ralph Wiggum Plugin: You tell Ralph what you want → Walk away → Come back to finished work. The autonomous loop handles everything.

What is an Autonomous Loop in Claude Code?

An autonomous loop is AI that keeps working without you. The Ralph Wiggum plugin creates these autonomous loops in Claude Code.

You give Claude Code a task with clear "done" criteria
Claude Code tries to complete it
When Claude tries to stop, the Ralph Wiggum plugin checks if it's actually done
If not done: Ralph restarts Claude Code with the same task
Claude Code sees previous attempts and tries a different approach
The autonomous loop repeats until done or hits your iteration limit

The key: Each loop is smarter because it learns from previous failures.

flowchart TD
    Start([You: Give task with 'done' criteria]) --> Claude[Claude attempts task]
    Claude --> Ralph{Ralph checks:<br/>Is it done?}
    Ralph -->|Not done| Restart[Ralph restarts Claude<br/>with same task]
    Restart --> Learn[Claude sees previous attempts<br/>tries different approach]
    Learn --> Claude
    Ralph -->|Done| Success([✅ Task Complete])
    Ralph -->|Max iterations| Limit([⏱️ Hit iteration limit])

    style Start fill:#C2E476,stroke:#795BC2,stroke-width:2px,color:#0B211F
    style Success fill:#C2E476,stroke:#795BC2,stroke-width:2px,color:#0B211F
    style Limit fill:#795BC2,stroke:#C2E476,stroke-width:2px,color:#fff
    style Ralph fill:#795BC2,stroke:#C2E476,stroke-width:2px,color:#fff
    style Claude fill:#10312D,stroke:#795BC2,stroke-width:2px,color:#C2E476
    style Restart fill:#10312D,stroke:#C2E476,stroke-width:2px,color:#C2E476
    style Learn fill:#10312D,stroke:#C2E476,stroke-width:2px,color:#C2E476

Why Do We Need This?

The Normal Problem

You: "Add user authentication"
Claude: *generates code*
You: "No, use JWT tokens"
Claude: *updates code*
You: "The password reset is missing"
Claude: *adds password reset*
You: "Tests are failing"
Claude: *fixes tests*

Exhausting and slow.

The Ralph Solution

You: "Add user authentication with JWT tokens, password reset,
and tests with >80% coverage. Done means all tests pass."
Ralph: *works for 2 hours*
Ralph: "Complete. All tests passing."

One detailed instruction. Walk away. Come back to finished work.

When to Use Ralph Wiggum Plugin (And When Not To)

✅ Use Ralph For:

Mechanical tasks: "Add JSDoc comments to every function"
Tasks with tests: Anything that can verify itself automatically
Big refactors: Framework upgrades, dependency updates
Overnight work: Queue it Friday, review Monday

❌ Don't Use Ralph For:

Judgment calls: Architecture decisions, design choices, security code
Vague tasks: "Make the UI better"
Production fires: When things are broken NOW
Quick tasks: If it takes 2 minutes manually, just do it

Rule: If you can describe exactly what "done" looks like, the Ralph Wiggum plugin can probably do it using autonomous loops.

How to Install and Use Ralph Wiggum Plugin: Quick Start Guide

Install

/plugin install ralph-wiggum@claude-plugins-official

Commands

Start an autonomous loop:

/ralph-wiggum:ralph-loop "<task>" --max-iterations 30

Start autonomous loop with auto-stop:

/ralph-wiggum:ralph-loop "<task>" --max-iterations 30 --completion-promise "COMPLETE"

Cancel Ralph Wiggum plugin:

/ralph-wiggum:cancel-ralph

Example: Add Documentation

Bad prompt:

/ralph-wiggum:ralph-loop "Add comments to my functions" --max-iterations 10

Good prompt:

/ralph-wiggum:ralph-loop "Add JSDoc comments to every exported function in src/utils/.

Rules:
- Every exported function gets JSDoc
- Include @param, @returns, @throws
- Use clear descriptions

Done means: Every exported function has complete JSDoc.

Output <promise>DOCUMENTED</promise> when complete." --max-iterations 20 --completion-promise "DOCUMENTED"

Why the good prompt works:

Clear scope (src/utils)
Specific rules
Clear "done" criteria
Safety limit (20 iterations)

The Secret: BrainGrid Makes Perfect Prompts

Here's what everyone misses: The Ralph Wiggum plugin is only as good as your prompt.

Writing good prompts is hard. You need to think through every edge case, acceptance criteria, and implementation detail.

This is where BrainGrid changes everything.

Without BrainGrid

Your vague idea: "Add user authentication"

You write a prompt, but what does "authentication" mean? Email/password? OAuth? Password reset? Rate limiting? The Ralph Wiggum plugin burns iterations guessing.

With BrainGrid MCP

BrainGrid connects to Claude Code via MCP (Model Context Protocol), giving Claude direct access to structured requirements without copy-pasting.

Step 1: Set up BrainGrid MCP

First, connect BrainGrid to Claude Code:

claude mcp add --transport http braingrid https://mcp.braingrid.ai

Verify the connection:

/mcp

You should see braingrid listed. BrainGrid will prompt you to authorize via OAuth in your browser.

Step 2: Create a requirement in BrainGrid

In Claude Code, ask:

"Create a requirement in BrainGrid for user authentication system"

Claude (with BrainGrid MCP) creates a structured requirement with:

Clear description
Acceptance criteria
Technical constraints
Test requirements

Step 3: Refine in BrainGrid dashboard

Head to BrainGrid AI Dashboard and work with the BrainGrid agent:

"Help me refine this requirement and ask any clarifying questions"

The agent helps you catch missing details and edge cases.

Step 4: Break down into tasks

In the BrainGrid dashboard, click "Break down requirement into tasks." BrainGrid generates concrete, implementable tasks tied to REQ-456.

Step 5: Build with Ralph + BrainGrid

Now the magic happens. In Claude Code:

/ralph-wiggum:ralph-loop "Build REQ-456 from BrainGrid" --max-iterations 40

Ralph automatically:

Fetches the full requirement from BrainGrid via MCP
Reads all acceptance criteria
Understands technical constraints
Knows how to verify completion
Builds with complete context

No copy-pasting. No missing details. Ralph just points at the BrainGrid requirement and builds it correctly.

The Difference

Without BrainGrid: Vague prompt → Ralph Wiggum plugin guesses → Wastes iterations → Wrong implementation

With BrainGrid MCP: Detailed requirement → Ralph Wiggum plugin fetches full context → Builds it right the first time

The Complete Workflow

flowchart LR
    A[💡 Rough idea<br/>in Claude Code] --> B[📝 Create requirement<br/>in BrainGrid]
    B --> C[🔍 Refine requirement<br/>in BrainGrid dashboard]
    C --> D[📋 Break down into tasks<br/>in BrainGrid]
    D --> E[🤖 Build REQ-456<br/>with Ralph]
    E --> F[✅ Working feature<br/>with tests]

    style A fill:#C2E476,stroke:#795BC2,stroke-width:2px,color:#0B211F
    style B fill:#795BC2,stroke:#C2E476,stroke-width:2px,color:#fff
    style C fill:#795BC2,stroke:#C2E476,stroke-width:2px,color:#fff
    style D fill:#795BC2,stroke:#C2E476,stroke-width:2px,color:#fff
    style E fill:#10312D,stroke:#C2E476,stroke-width:2px,color:#C2E476
    style F fill:#C2E476,stroke:#795BC2,stroke-width:2px,color:#0B211F

BrainGrid = The thinking phase (what to build)
Ralph = The execution phase (building it)

Most people skip the thinking phase and jump straight to execution. That's why their prompts fail and the Ralph Wiggum plugin spins endlessly in autonomous loops.

Setup guide: BrainGrid MCP Integration

Try BrainGrid free: braingrid.ai

Ready-to-Use Templates

Feature Implementation

/ralph-wiggum:ralph-loop "Build user profile edit feature.

What it needs:
- Form with name, email, bio fields
- Save button calls /api/users/me
- Show success/error messages
- All fields required except bio

Tests: Form renders, validation works, API called correctly

Done means: Feature works and tests pass.

Output <promise>COMPLETE</promise> when done." --max-iterations 30

Bug Fix

/ralph-wiggum:ralph-loop "Fix: Users can submit empty contact form.

Steps:
1. Add validation for required fields (name, email, message)
2. Show error messages for empty fields
3. Prevent submission if validation fails
4. Add test to prevent regression

Done means: Empty form blocked and test proves it.

Output <promise>FIXED</promise> when done." --max-iterations 15

Quick Tips

Prompt Checklist:

✅ Clear scope (what files/features)
✅ Specific requirements (what to do)
✅ "Done" definition (how to verify)
✅ Safety limit (--max-iterations)

Iteration Guidelines:

Simple tasks: 10-20 iterations
Medium features: 20-40 iterations
Complex builds: 40-60 iterations
Always set --max-iterations (never unlimited)

Cost Estimates:

Small task: $5-20
Medium feature: $30-60
Large build: $60-150+

Pro tip: Test manually with one iteration before running 50-iteration loops.

Ralph Wiggum Plugin Troubleshooting

Loop never completes?
Your "done" criteria aren't clear enough. Be more specific.

Same error every loop?
Add to prompt: "If stuck after 10 tries, document the error and stop."

Costs too high?
Lower --max-iterations, use .claudeignore, break into smaller tasks.

Windows issues?
Install jq: choco install jq or use WSL.

Frequently Asked Questions About Ralph Wiggum Plugin

What is the Ralph Wiggum plugin?

The Ralph Wiggum plugin is an official Claude Code plugin that creates autonomous loops. It allows Claude Code to work continuously on a task, automatically restarting and trying different approaches until the task is complete or the iteration limit is reached.

How do autonomous loops work in Claude Code?

Autonomous loops work by: (1) You provide a task with clear "done" criteria, (2) Claude Code attempts the task, (3) Ralph Wiggum checks if it's actually done, (4) If not done, Ralph restarts Claude with the same task, (5) Claude sees previous attempts and tries a different approach, (6) This repeats until done or the iteration limit is hit.

How do I install the Ralph Wiggum plugin?

Install the Ralph Wiggum plugin in Claude Code using:

/plugin install ralph-wiggum@claude-plugins-official

What commands does the Ralph Wiggum plugin support?

The Ralph Wiggum plugin supports three main commands:

Start a loop: /ralph-wiggum:ralph-loop "<task>" --max-iterations 30
Start with auto-stop: /ralph-wiggum:ralph-loop "<task>" --max-iterations 30 --completion-promise "COMPLETE"
Cancel: /ralph-wiggum:cancel-ralph

When should I use Ralph Wiggum plugin?

Use the Ralph Wiggum plugin for mechanical tasks, tasks with automated tests, big refactors, and overnight work. Don't use it for judgment calls, vague tasks, production emergencies, or quick 2-minute tasks.

How much does Ralph Wiggum plugin cost?

Cost estimates for Ralph Wiggum plugin usage:

Small task: $5-20
Medium feature: $30-60
Large build: $60-150+

Can I use Ralph Wiggum with BrainGrid?

Yes! BrainGrid MCP integration works perfectly with Ralph Wiggum plugin. BrainGrid helps create structured requirements that Ralph can fetch and build, resulting in better prompts and fewer wasted iterations.

Conclusion

The Ralph Wiggum plugin removes the iteration tax from mechanical work in Claude Code.

The shift:

Before: 3 hours of back-and-forth implementing a feature
After: 10 minutes writing a clear prompt, then do other work while Ralph builds

Start small. Document one folder. Fix linter errors in one directory. Build confidence in what prompts work.

Then scale up. Queue overnight work. Run parallel loops. Let Ralph handle the boring parts while you focus on hard problems.

Install Ralph Wiggum plugin now:

/plugin install ralph-wiggum@claude-plugins-official

Want perfect prompts every time? BrainGrid helps you think through requirements so the Ralph Wiggum plugin builds it right the first time using autonomous loops.

Try BrainGrid + Ralph free →

Originally published on the BrainGrid blog.

Windsurf MCP Servers: Setup Guide + Best Servers (2026)

Nico Acosta — Sat, 04 Jul 2026 11:12:57 +0000

Every time Windsurf's AI writes database code, it guesses at your schema. Every API call gets placeholder responses you'll need to fix manually. That copy-paste cycle kills your momentum—and it doesn't have to be this way.

Model Context Protocol (MCP) servers connect Windsurf to your actual databases, APIs, and external services. Instead of generating boilerplate that needs fixing, Windsurf's agents query your real systems and write code that works the first time.

In this guide, you'll learn what MCP servers are, how to set them up in Windsurf, and which servers will help you ship faster.

What is MCP in Windsurf?

MCP servers are bridges between Windsurf and external services. They give Windsurf's agents context beyond your codebase—databases, APIs, cloud infrastructure, and more.

After connecting a database MCP server, Windsurf's agents can examine your actual tables and columns. The code it generates is based on real queries that retrieve data correctly, and does not rely on placeholder SQL that must be manually updated.

Why MCP Matters for Shipping Faster

The same pattern applies across your entire stack. An API MCP server lets Windsurf call actual endpoints and write code that correctly parses real responses. A GitHub MCP server gives context about open issues and PRs.

Without MCP, you're stuck fixing the same boilerplate over and over—copying real values into placeholder code. With MCP, the agents generate code that works the first time, letting you ship faster with fewer manual fixes.

How to Set Up MCP Servers in Windsurf

Many MCP servers are available for Windsurf. Some install directly from the MCP Marketplace with a few clicks, while others require manual JSON configuration.

Installing from the MCP Marketplace

To access the MCP Marketplace, open Windsurf Settings (on Mac: Windsurf → Settings → Windsurf Settings or press ⌘,). Search for "MCP" and click the link to open the Marketplace.

The marketplace offers many MCP servers ready to install.

For example, the PostgreSQL MCP server walks you through connection setup—host, port, credentials—and automatically populates the JSON config when complete.

Installing MCPs manually with JSON

If your MCP server isn't in the Marketplace, you can add it manually by editing the mcp_config.json file. Access this file from the Marketplace by clicking the gear icon.

Here is an example mcp_config.json file with two MCP servers set up, BrainGrid, and the PostgreSQL set up from the marketplace:

{
  "mcpServers": {
    "braingrid": {
      "args": [
        "-y",
        "mcp-remote@latest",
        "https://mcp.braingrid.ai/mcp"
      ],
      "command": "npx"
    },
    "postgresql": {
      "args": [
        "run",
        "-i",
        "--rm",
        "mcp/postgres",
        "postgresql://admin:admin@example.com:5432/my-secret-database"
      ],
      "command": "docker",
      "disabled": false,
      "env": {}
    }
  }
}

This JSON file includes servers installed via the Marketplace as well as manually added ones. The Marketplace simplifies setup by properly formatting the JSON entry for you. The PostgreSQL MCP server creates a small local Docker container with Postgres utilities and your database connection details.

For BrainGrid MCP installation, follow the official setup guide.

Windsurf MCP Configuration Format

Each MCP entry specifies a command (like npx or docker) and args (the arguments to pass). Windsurf runs these commands when it starts, establishing the MCP server connections.

Top MCP Servers for Windsurf Developers

Databases: There are MCP servers for most major databases and DB-as-a-service platforms (MySQL, postgres, MongoDB, Redis, Neon, etc.)
CloudOps: AWS and Heroku MCP servers give Windsurf insight into how the application is deployed and configured in the cloud. Additionally access to logs and environment specific behavior can help Windsurf improve reliability.
GitHub: Agents can read pull requests, inspect issues, and understand commit history. This repository content does not live in the codebase, but influences how the code should change.
Stripe: Visibility into billing flows, customers, subscriptions, invoices, and webhooks. Agents can debug and reason about how the billing logic interacts with the codebase.
BrainGrid: Takes vague development ideas, turns them into explicit requirements, and breaks those requirements into structured tasks the agents can execute.
Swagger: When agents are able to read the API specs, they can build to existing endpoints, and parse the results in based on actual responses from the API. No more hallucinated or boilerplate API code to be fixed.

Note that each MCP provides a number of tools to Windsurf, and that Windsurf places a cap of 100 tools that can be active. This might mean enabling and disabling MCPs during different phases of coding.

BrainGrid MCP: Spec-Driven Development in Windsurf

BrainGrid is an AI product manager that helps developers plan, specify, and build new features. Often, developers jump right in and start prompting before they have a clear picture of what they're building. Running those initial ideas through BrainGrid turns them into structured requirements.

For example, say you want to add a billing flow to your application. BrainGrid analyzes your existing code and asks clarifying questions: which payment providers, what subscription tiers, how to handle failures. These answers become a requirements document your team can approve—spec-driven development. BrainGrid then breaks the requirements into implementation tasks.

The BrainGrid MCP lets Windsurf access these requirements and tasks directly. Instead of copying prompts into the chat, Windsurf reads the full context and builds the feature.

The result: agents build exactly what you specified, with less cleanup afterward. Less context-switching, faster shipping.

Troubleshooting Common Windsurf MCP Issues

Command not found: If Docker isn't running locally, Docker-based MCPs will fail. Start Docker first.
Missing dependencies: Some MCPs require packages like mcp-remote. Install them before configuring.
Changes not taking effect: After installing new dependencies, restart Windsurf to pick up the changes.

Start Shipping Faster Today

MCP servers give Windsurf's agents the full picture: databases, APIs, issues, designs, and more. With this context, the code they produce is higher quality and far less likely to need the manual fixes you've come to expect from AI-generated code.

When agents build closer to what you actually need, you ship faster. Less time fixing, more time launching.

Ready to go further? BrainGrid adds spec-driven development to your workflow—turning vague ideas into structured requirements that generate precise prompts for Windsurf's agents.

Frequently Asked Questions

What is MCP in Windsurf?

MCP (Model Context Protocol) gives Windsurf's agents context beyond your codebase. This includes cloud services, databases, API specifications, or any third-party service that provides insight into how your application works.

How do I configure MCP servers in Windsurf?

Use the MCP Marketplace for one-click installs, or manually edit the mcp_config.json file with the server configuration.

Where is the Windsurf MCP config file located?

The config file is at ~/.codeium/windsurf/mcp_config.json. The easiest way to access it is through the MCP Marketplace by clicking the settings gear icon.

What MCP servers work with Windsurf?

Any MCP server using stdio (local) or http (remote) transport works with Windsurf.

How does Windsurf MCP compare to Cursor MCP?

Both support MCP, but they use it differently. Cursor treats MCP as a transactional tool—query and respond. Windsurf integrates MCP into its agentic workflow, using the context for multi-step planning and chaining data across tasks.

Why is my Windsurf MCP server not working?

Check the troubleshooting section above. The MCP Marketplace shows connection status—look there for specific error messages to diagnose the issue.

Originally published on the BrainGrid blog.

10 Best Lovable Alternatives in 2026 (Reviewed & Compared)

Nico Acosta — Fri, 03 Jul 2026 11:13:55 +0000

You've heard about Lovable. Maybe you've tried it. The pitch is simple: describe your app in plain English, watch AI build it. No code required.

But here's the reality: Lovable isn't the only tool turning ideas into working software. Depending on what you're building and how you work, it might not even be the best one.

This guide breaks down ten alternatives developers and non-technical builders actually use to ship real products. No fluff—just what each tool does well, where it fails, and who should care.

What Is Lovable and Why Look for Alternatives?

Lovable is an AI web app builder that generates full-stack applications from text descriptions. Popular with non-technical founders who want to validate ideas fast without hiring developers.

The appeal? Speed. Ideas become clickable demos in minutes instead of weeks.

The tradeoffs? Limited customization as apps grow complex. Managing changes at scale gets harder. And if you want to own your codebase fully, tools that export clean, modifiable code feel more sustainable. (Already decided to export? Here's how to download your Lovable project in 15 minutes.)

Different tools optimize for different priorities: code ownership, visual control, terminal workflows, production architecture, or team collaboration. The right tool depends on what you're building and how you build it.

1. Bolt.new: Browser to Deployed App in Seconds

Bolt.new, built by StackBlitz, turns prompts into live, deployed web apps. Type "Build a CRM with contact notes and Kanban board"—Bolt generates the full-stack app and deploys it instantly.

What makes it different: Instant deployment. No export or hosting step. Your app is live and shareable the moment it's generated. Powered by Claude Sonnet 4.0, handles React frontends, Node.js backends, and Supabase databases automatically.

The feature most people miss: React Native and Expo support. Unlike other tools that stop at web apps, Bolt generates native iOS and Android apps you can preview on your device. No Xcode or Android Studio required.

Best for: Non-technical founders needing a working prototype today. Agencies showing clients proof-of-concept. Mobile app builders prototyping without native toolchains.

Where it struggles: AI-generated code needs review and debugging. Complex enterprise apps with intricate business logic outgrow the browser environment. Optimized for speed and prototyping, not production-scale depth.

2. BrainGrid AI: The Product Manager Your Coding Agent Needs

Here's the problem most builders face with AI coding tools: you describe what you want, get something close but wrong, then spend hours iterating back and forth. The issue isn't the coding tool—it's unclear requirements.

BrainGrid AI doesn't generate code. It generates the plans your coding agents need to generate the right code the first time.

How It Works

Think of BrainGrid as an experienced product manager sitting between you and your coding tools. You describe what you want to build, and BrainGrid asks the clarifying questions: What happens if the user does X? What's the error state? How should this integrate with existing features?

Then it creates detailed specifications and breaks features into well-scoped tasks with clear acceptance criteria. Each task is specific enough that when you hand it to Cursor, Claude Code, or any AI coding tool, the tool builds it correctly the first time.

Why Requirements Matter

Most AI coding failures happen before code gets written. Vague prompts like "add user authentication" lead to vague implementations that miss edge cases and create bugs. BrainGrid forces clarity upfront.

Instead of "add user authentication," BrainGrid helps you spec out: email/password or OAuth? Password reset flow? Session management? Rate limiting? Each detail becomes a clear task.

Best for: Non-technical founders building with AI tools who keep hitting the "that's not what I meant" problem. Developers managing complex features who want to plan before they code.

Where it struggles: If you already know exactly what you're building down to implementation details, the planning phase feels like extra steps.

3. Cursor: AI Code Editor That Understands Your Codebase

Cursor rebuilt VS Code from scratch with AI as the core feature. Instead of switching between your editor and ChatGPT, you work inside Cursor. The AI sees your entire codebase, so suggestions are contextually aware, not generic.

The standout feature: Cmd+K. Select code, describe what you want changed, Cursor edits it inline. No copy-pasting. No breaking your flow. Feels like having a senior developer who instantly understands your codebase.

Best for: Developers who want AI assistance without leaving their editor. Teams using VS Code who want the smoothest upgrade to AI-assisted coding.

Where it struggles: Non-developers. If you don't already code, Cursor won't teach you. It accelerates developers; doesn't replace them.

4. Claude Code: Autonomous Coding from Your Terminal

Claude Code is Anthropic's command-line agent. You describe a task, it works autonomously—reading files, running commands, making edits, verifying work—without babysitting each step.

The difference is autonomy. Most AI tools wait for your input between steps. Claude Code operates like a junior developer you've delegated to. It figures out what files to read, runs tests to verify nothing broke, and only interrupts if it needs clarification.

Best for: Developers comfortable with terminal workflows. Engineers delegating entire features. Large refactors or migrations where the task is clear but tedious.

Where it struggles: Visual work. If your task involves design decisions or requires seeing the UI, terminal-only becomes limiting.

5. v0 by Vercel: UI Focused Vibe Coding Tool

If you care what your app looks like, v0 by Vercel deserves attention. Built by Vercel, specializes in generating React components with shadcn/ui that actually look hand-crafted.

You describe a UI element—pricing table, dashboard card, contact form—v0 generates component code. The difference is design quality. Components feel intentional: proper spacing, typography, visual hierarchy.

Integrates tightly with Next.js and shadcn/ui, so code fits naturally into existing projects.

Best for: Developers building Next.js apps who want to accelerate UI work. Design-conscious founders who know the difference between "functional" and "professionally designed."

Where it struggles: Full application logic. v0 generates components, not entire apps. You still wire up state management, routing, and business logic yourself.

6. Emergent: Full-Stack Vibe Coding with Multi-Agent Architecture

Emergent is a full-stack vibe coding platform that handles the complete development lifecycle. You describe what you want in plain English, and Emergent's multi-agent system builds it.

What sets it apart: Multi-agent architecture. Specialized agents handle specific tasks—a Builder Agent creates code, a Quality Agent runs tests, a Deploy Agent handles cloud deployment, and an Optimizer Agent improves SEO and accessibility. This produces more reliable results than single-agent systems.

Runs entirely in the browser on Google Cloud Platform VMs. Build with React, Next.js, Expo, or Python with full code access and export control.

Best for: Developers who want full-stack control with AI assistance. Non-technical founders building production-ready apps. Teams needing reliable multi-agent workflows.

Where it struggles: Learning curve for advanced workflows. Credit costs add up for multiple high-capacity projects. Requires stable internet.

7. Rocket.new: AI Debugging That Fixes Issues Before You See Them

Rocket.new manages the full app lifecycle—from ideation to deployment—in a single workspace. You describe your app idea, and Rocket.new generates frontend, backend, and database setup automatically.

What makes it stand out: Smart debugging system. The built-in AI debugger continuously scans for syntax errors, performance issues, or broken dependencies. When detected, it suggests or applies fixes automatically, ensuring cleaner builds without debugging cycles.

Includes modular component library with prebuilt UI elements and auto-generated technical documentation.

Best for: Startups aiming for quick MVPs. Individual developers who want AI-assisted debugging. Teams needing GitHub integration built in.

Where it struggles: Limited customization for complex enterprise projects. Auto-generated code sometimes needs manual optimization for scalability.

8. Replit: Code and Deploy Without Leaving Your Browser

Replit is a browser-based development environment for building and hosting apps. Zero setup—no configuring Node, Python, databases, or environments. Pick a template, start coding, everything works.

Replit AI helps you write code, debug errors, and explain concepts as you work.

Best for: Students learning to code. Non-technical founders dabbling in coding without full local setup. Developers prototyping quickly.

Where it struggles: Large production-scale applications. Optimized for learning and prototyping, not managing complex enterprise codebases.

9. Co.dev: Collaborative AI Workspace for Cross-Functional Teams

Co.dev brings developers, designers, and product owners together in a shared environment. Everyone can contribute to application logic, layout, and deployment in real time.

What makes it different: Cross-functional collaboration focus. Instead of developers in one tool, designers in another, and PMs in spreadsheets, Co.dev centralizes the entire workflow with real-time collaborative coding and AI-assisted task automation.

Supports React-based frontends and serverless backends with GitHub, API, and cloud deployment integrations.

Best for: Product teams where designers, developers, and PMs collaborate tightly. Small agencies building client projects. Solo developers planning to grow into a team.

Where it struggles: Requires stable internet. Some advanced backend features need external integrations. AI accuracy varies by task complexity.

10. Base44: No-Code Platform with Low-Code Flexibility

Base44 helps individuals, startups, and small teams rapidly build web applications, dashboards, and automation workflows without traditional coding.

What makes it stand out: Visual drag-and-drop interface with AI-assisted workflow automation. You design interfaces visually, and the AI generates workflows, connects databases, and sets triggers. Built-in database and cloud storage eliminate external dependencies.

Features AI-powered component suggestions, adaptive workflows, cross-device testing, and smart data linking.

Best for: Non-technical founders who want to build functional apps quickly. Small teams needing rapid prototyping with visual tools.

Where it struggles: Limited flexibility for complex custom backend logic. Performance can lag with extremely high data volumes.

Which Tool Should You Actually Use?

The honest answer: it depends on how you work and what you're building. For a hands-on test where we built the same app with each tool, see our best vibe coding tools in 2026 guide.

graph TD
    Start[Choose Your Tool] --> Q1{Requirements<br/>Clear?}

    Q1 -->|No| BrainGrid[BrainGrid AI<br/>Plan & Clarify]
    Q1 -->|Yes| Q2{What's Your<br/>Priority?}

    Q2 -->|Speed/Prototype| Q3{Full App or<br/>Just UI?}
    Q3 -->|Full App| Bolt[Bolt.new<br/>Instant Deploy]
    Q3 -->|UI Components| V0[v0<br/>Professional UI]

    Q2 -->|Development| Q4{Terminal or<br/>Editor?}
    Q4 -->|Editor| Cursor[Cursor<br/>AI Code Editor]
    Q4 -->|Terminal| Claude[Claude Code<br/>Autonomous Agent]

    Q2 -->|Full-Stack| Q5{Need Multi-Agent<br/>Architecture?}
    Q5 -->|Yes| Emergent[Emergent<br/>Multi-Agent System]
    Q5 -->|No| Rocket[Rocket.new<br/>AI Debugging]

    Q2 -->|Learning| Replit[Replit<br/>Browser-Based]

    Q2 -->|Team Collab| Codev[Co.dev<br/>Cross-Functional]

    Q2 -->|No-Code| Base44[Base44<br/>Visual Builder]

    BrainGrid -.->|Then Use| Q2

    style Start fill:#4CAF50,stroke:#2E7D32,stroke-width:3px,color:#fff
    style BrainGrid fill:#FF6B6B,stroke:#C92A2A,stroke-width:2px,color:#fff
    style Bolt fill:#3B82F6,stroke:#1E40AF,stroke-width:2px,color:#fff
    style V0 fill:#3B82F6,stroke:#1E40AF,stroke-width:2px,color:#fff
    style Cursor fill:#8B5CF6,stroke:#6D28D9,stroke-width:2px,color:#fff
    style Claude fill:#8B5CF6,stroke:#6D28D9,stroke-width:2px,color:#fff
    style Emergent fill:#10B981,stroke:#047857,stroke-width:2px,color:#fff
    style Rocket fill:#10B981,stroke:#047857,stroke-width:2px,color:#fff
    style Replit fill:#F59E0B,stroke:#D97706,stroke-width:2px,color:#fff
    style Codev fill:#EC4899,stroke:#BE185D,stroke-width:2px,color:#fff
    style Base44 fill:#6366F1,stroke:#4338CA,stroke-width:2px,color:#fff

Quick decision guide:

Planning unclear features? Start with BrainGrid to clarify requirements
Need a prototype by end of day? Bolt.new for full apps, v0 for UI
Developer staying in your editor? Cursor for AI-assisted coding
Terminal-first workflows? Claude Code for autonomous task completion
Full-stack with multi-agent architecture? Emergent for complex projects
AI debugging that fixes issues automatically? Rocket.new for cleaner builds
Learning to code or quick experiments? Replit for zero-setup development
Team collaboration across functions? Co.dev for cross-functional teams
Visual no-code with AI automation? Base44 for drag-and-drop interfaces

The Pattern That Works

Most successful builders don't use just one tool. They combine them strategically:

Plan with BrainGrid to clarify requirements and break features into clear tasks
Build with coding tools (Cursor, Claude Code, Emergent, Rocket.new)
Polish with specialized tools (v0 for UI, Bolt.new for prototypes)
Deploy and iterate based on user feedback

The tools complement each other. BrainGrid ensures you're building the right thing. Coding tools build it efficiently. Specialized tools polish the details.

The critical mistake: Assuming one tool does everything. The right stack depends on your skills, your project, and what slows you down most.

The Real Cost of Choosing Wrong

Picking the wrong tool doesn't just waste time—it creates technical debt that slows you down later.

Use a visual builder for complex logic? Eventually hit platform limits and face painful migration. Use a code generator with messy output? Codebase becomes unmaintainable. Skip planning and jump to coding? Spend more time debugging vague implementations than you saved moving fast.

Before you pick one, ask yourself:

Do I need to own and modify the code, or is a hosted platform fine?
Am I building a prototype to validate an idea, or a product I'll scale?
Do I know how to code, or am I learning as I build?
Are my requirements clear, or do I need help defining what to build?

The answers matter more than feature lists or pricing tiers.

Conclusion: Stop Building Wrong, Start Shipping Right

The AI coding landscape in 2026 offers more options than ever. But having options doesn't matter if you're building the wrong thing.

Here's what we've learned watching builders ship: the workflow matters more than the tools themselves.

The fastest builders aren't the ones who jump straight into coding with the newest AI tool. They're the ones who take time to clarify requirements first, then execute efficiently with whatever tools fit their workflow.

That's why BrainGrid exists. Not to replace your coding tools, but to make them actually work. Clear requirements mean your AI coding tool builds it right the first time. Less iteration. Fewer bugs. Faster shipping.

Whether you choose Bolt.new for prototypes, Cursor for development, Emergent for full-stack projects, or any other tool on this list—start by getting clear on what you're building. The tools will take care of the rest.

Stop guessing. Start shipping.

Originally published on the BrainGrid blog.

Claude Agent SDK: Build Production AI Agents Without Starting from Scratch

Nico Acosta — Thu, 02 Jul 2026 11:13:06 +0000

You've been building features by hand while your competitors ship AI agents that work around the clock. The Claude Agent SDK—the same engine powering Claude Code—is now available as a library.

In the next 20 minutes, you'll understand exactly how to build an autonomous agent that reads your codebase, fixes bugs, and ships features while you focus on landing customers. No PhD required. No six-month learning curve. Just working code you can deploy this weekend.

What Is the Claude Agent SDK and Why Should You Care?

Here's the situation: you've seen what Claude Code can do. It reads files, runs commands, fixes bugs, and ships features autonomously. What you might not know is that the entire engine powering Claude Code is now available as a library you can drop into your own product.

That's the Claude Agent SDK.

Think of it this way: if Claude Code is the finished car, the Agent SDK is the engine you can install in your own chassis. Same power, your design. The SDK gives you Claude's entire agent loop—the part that decides what to do, uses tools, and verifies its work—without you having to reinvent any of it.

One important note: you might see references to "Claude Code SDK" in older articles or search results. Anthropic renamed it to "Claude Agent SDK" in late 2025 to reflect its broader use cases beyond just coding tasks.

Don't confuse this with the Anthropic Client SDK. The Client SDK requires you to implement the tool loop yourself—you send a prompt, get a response, execute any tools manually, send results back, repeat. It's a lot of plumbing.

The Agent SDK handles all of that autonomously. You send a prompt, and the agent reads files, runs commands, makes edits, and verifies its own work without you writing the orchestration logic.

flowchart LR
    subgraph ClientSDK["Client SDK (Manual)"]
        A1[Send Prompt] --> B1[Get Response]
        B1 --> C1{Tool Use?}
        C1 -->|Yes| D1[YOU Execute Tool]
        D1 --> E1[Send Result Back]
        E1 --> B1
        C1 -->|No| F1[Done]
    end

    subgraph AgentSDK["Agent SDK (Autonomous)"]
        A2[Send Prompt] --> B2[Agent Loop]
        B2 --> C2[SDK Executes Tools]
        C2 --> D2[SDK Verifies]
        D2 --> B2
        B2 --> E2[Done]
    end

What does this mean for your product? Your agent can handle customer support tickets, debug code, generate reports, or analyze documents while you sleep. Each of those is a potential paid feature. The SDK removes the build-from-scratch tax so you can focus on what makes your product unique.

How Do I Install and Set Up the Claude Agent SDK?

A botched setup can waste hours. Let's get this right the first time so you're building in minutes, not debugging your environment.

The SDK comes in two flavors: TypeScript and Python. Pick whichever matches your stack. Both have identical capabilities—the agent loop, built-in tools, streaming, sessions, everything.

Requirements:

Python 3.10+ for the Python SDK
Node.js 18+ for the TypeScript SDK
Claude Code CLI is bundled automatically with both packages

Here's the copy-paste installation:

## TypeScript/Node.js
npm install @anthropic-ai/claude-agent-sdk

## Python
pip install claude-agent-sdk

## Set your API key (get it from console.anthropic.com)
export ANTHROPIC_API_KEY=your-api-key

That's it. One command and you're ready.

One gotcha that trips people up: version mismatch between the Claude Code CLI and the SDK. If you're getting weird agent recognition errors, run claude --version and make sure it matches the SDK requirements in the docs. This is the most common support question on the GitHub issues, and the fix is always "update your CLI."

Never hardcode your API key in source files. Environment variables keep your credentials out of git history and make deployment cleaner. Your future self (and anyone who reviews your code) will thank you.

Faster setup means faster time-to-demo. When a potential customer asks "can you show me how this works?", you want to be deploying agents, not debugging npm installs.

What's the Core Agent Loop and How Does It Work?

Understanding the agent loop is the difference between debugging agents quickly and spending days confused about why your agent isn't working.

The loop has three phases that repeat until the task is done:

Gather context - The agent reads files, searches the codebase, or spawns subagents to collect information
Take action - Execute tools, run bash commands, generate code, make edits
Verify work - Check if the output is correct, run tests, validate assumptions

If verification fails, the loop repeats. The agent gathers more context, tries a different approach, and verifies again. This feedback mechanism is what makes agents actually useful—they self-correct instead of confidently shipping broken code.

flowchart TD
    A[Start Task] --> B[Gather Context]
    B --> B1[Search Files]
    B --> B2[Read Documentation]
    B --> B3[Spawn Subagents]
    B1 & B2 & B3 --> C[Take Action]
    C --> C1[Execute Tools]
    C --> C2[Run Scripts]
    C --> C3[Generate Code]
    C1 & C2 & C3 --> D[Verify Work]
    D --> D1{Passes Checks?}
    D1 -->|No| B
    D1 -->|Yes| E[Complete]
    style B fill:#10312D,color:#FCFCFB
    style C fill:#C2E476,color:#121212
    style D fill:#AACF57,color:#121212

Here's the loop in action:

```typescript "TypeScript"
import { query } from "@anthropic-ai/claude-agent-sdk";

// The SDK handles the entire loop for you
for await (const message of query({
prompt: "Find and fix the bug in auth.py",
options: {
allowedTools: ["Read", "Edit", "Bash"],
permissionMode: "acceptEdits"
}
})) {
console.log(message);
// Claude reads the file, finds the bug, edits it, verifies the fix
}




The biggest pitfall here: agents try to one-shot complex tasks. They'll attempt to implement an entire feature in a single pass, run out of context mid-implementation, and leave you with half-working code. The fix is explicit task breakdown—give your agent smaller, focused tasks rather than "build me an authentication system."

Context management is the production differentiator. Pushing entire conversation history on each API call exhausts your token budget fast. The SDK includes automatic context compaction that summarizes older exchanges, but you should still design your prompts to request focused, specific actions.

A well-tuned agent loop handles 10x more customer requests without human intervention. That's the difference between a support burden and a profit center.

## What Built-In Tools Are Available and When Should I Use Each?

The SDK ships with eight core tools that handle 90% of what you'll need. Here's what each does and when to reach for it:

| Tool | What it does | When to use |
|------|--------------|-------------|
| **Read** | Read any file in the working directory | Viewing code, configs, documentation |
| **Write** | Create new files | Generating new components or configs |
| **Edit** | Make precise edits to existing files | Bug fixes, refactoring, updates |
| **Bash** | Run terminal commands and scripts | Git operations, npm, tests, builds |
| **Glob** | Find files by pattern | Discovering files: `**/*.ts`, `src/**/*.py` |
| **Grep** | Search file contents with regex | Finding function calls, variable usage |
| **WebSearch** | Search the internet | Looking up current documentation or APIs |
| **WebFetch** | Fetch and parse web pages | Reading docs, scraping structured data |



```mermaid
flowchart TD
    A[Task Type?] --> B{Read or Write?}
    B -->|Read| C{What are you reading?}
    C -->|Files| D[Use Read]
    C -->|Find Files| E[Use Glob]
    C -->|Search Content| F[Use Grep]
    C -->|Web Info| G[Use WebSearch/WebFetch]

    B -->|Write| H{What are you changing?}
    H -->|New File| I[Use Write]
    H -->|Edit Existing| J[Use Edit]
    H -->|Run Commands| K[Use Bash]
    style D fill:#AACF57,color:#121212
    style E fill:#AACF57,color:#121212
    style F fill:#AACF57,color:#121212
    style G fill:#10312D,color:#F3F1E8
    style I fill:#C2E476,color:#121212
    style J fill:#C2E476,color:#121212
    style K fill:#473392,color:#FCFCFB

Here's the critical security lesson: don't enable all tools by default. Start with read-only access (Read, Glob, Grep) and add write capabilities only after you've validated the agent's behavior. One Reddit thread described an agent that ran rm -rf on a test directory because Bash was enabled without restrictions. Start paranoid, loosen permissions carefully.

Each tool you enable is a capability you can market. "AI that fixes your bugs" requires the Edit tool. "AI that deploys your code" requires Bash. Think about which capabilities map to features your customers will pay for, then enable only those.

Building an agent is the easy part. Knowing which features to build first is where most founders waste months. BrainGrid turns your vague ideas into structured specs with AI-ready tasks—so you ship features that convert, not features that collect dust.

How Do I Add Custom Tools and Integrate External APIs?

Built-in tools cover file operations and web access. But your agent needs to talk to your product—your CRM, database, Stripe, Slack, whatever powers your business. That's where custom tools and MCP come in.

Model Context Protocol (MCP) is Anthropic's standardized way to connect agents to external services. Instead of writing OAuth flows and API wrappers yourself, you plug in pre-built MCP servers for Slack, GitHub, Asana, Playwright, databases, and hundreds more. They handle authentication and API calls. You just configure them.

Here's how to add browser automation with the Playwright MCP server:

import { query } from "@anthropic-ai/claude-agent-sdk";

for await (const message of query({
  prompt: "Open our pricing page and verify it loads correctly",
  options: {
    mcpServers: {
      playwright: {
        command: "npx",
        args: ["@playwright/mcp@latest"]
      }
    }
  }
})) {
  console.log(message);
}

For custom integrations that don't have pre-built servers, you define your own tools with input validation and safety guards:

import { z } from "zod";

const createContactTool = {
  name: "create_crm_contact",
  description: "Create a new contact in the CRM",
  inputSchema: z.object({
    email: z.string().email(),
    name: z.string().min(1),
    plan: z.enum(["free", "pro", "enterprise"])
  }),
  handler: async ({ input, context }) => {
    // Always add timeout protection
    const controller = new AbortController();
    const timeoutId = setTimeout(() => controller.abort(), 5000);

    try {
      const result = await crmClient.createContact(input, {
        signal: controller.signal
      });
      clearTimeout(timeoutId);
      return result;
    } catch (error) {
      clearTimeout(timeoutId);
      throw error;
    }
  }
};

flowchart LR
    A[Claude Agent] --> B[MCP Protocol]
    B --> C[Playwright MCP]
    B --> D[GitHub MCP]
    B --> E[Slack MCP]
    B --> F[Custom MCP]
    C --> G[Browser Automation]
    D --> H[GitHub API]
    E --> I[Slack API]
    F --> J[Your Database]
    style A fill:#C2E476,color:#121212
    style B fill:#10312D,color:#F3F1E8

The critical pitfall: failing to sandbox tools. Running shell commands or database queries without timeouts creates runaway processes and security holes. Every custom tool should have a timeout wrapper, input validation, and explicit error handling.

Every integration you add is a potential upsell. "Connect to Stripe" becomes a Pro feature. "Sync with Slack" becomes an Enterprise add-on. Plan your integrations around what customers will pay for before you build them.

How Do I Handle Long-Running Agents and Subagents?

Real production tasks take minutes or hours, not seconds. A security audit across a large codebase. Analyzing months of customer support tickets. Generating comprehensive documentation. Agents that crash mid-task lose customer data and trust.

The SDK handles this through two mechanisms: sessions and subagents.

Sessions maintain context across multiple exchanges. Your agent can work on a task, you can close your laptop, come back tomorrow, and resume exactly where it left off. Context is preserved—files read, analysis done, conversation history.

let sessionId: string;

// First query: capture session ID
for await (const message of query({
  prompt: "Read the authentication module and understand how it works",
  options: { allowedTools: ["Read", "Glob", "Grep"] }
})) {
  if (message.type === "system" && message.subtype === "init") {
    sessionId = message.session_id;
  }
}

// Later (hours or days later): resume with full context preserved
for await (const message of query({
  prompt: "Now find all places that call the auth module",
  options: { resume: sessionId }
})) {
  console.log(message);
  // Agent remembers everything from the first query
}

Subagents handle task complexity by isolating context windows. When your main agent hits a complex subtask, it spawns a specialized subagent to handle it. The subagent works in its own context, returns relevant excerpts, and the parent continues without context explosion.

import asyncio
from claude_agent_sdk import query, ClaudeAgentOptions

async def analyze_codebase():
    # Enable Task tool to let Claude spawn subagents automatically
    async for message in query(
        prompt="Analyze this codebase for security vulnerabilities",
        options=ClaudeAgentOptions(
            allowed_tools=["Read", "Glob", "Grep", "Task"]
        )
    ):
        print(message)
    # Claude may spawn subagents for:
    # - SQL injection analysis
    # - XSS vulnerability scanning
    # - Dependency auditing

asyncio.run(analyze_codebase())

flowchart TD
    A[Parent Agent] --> B[Analyze Task]
    B --> C{Complex Enough?}
    C -->|Yes| D[Spawn Subagents]
    D --> E[Security Subagent]
    D --> F[Performance Subagent]
    D --> G[Documentation Subagent]
    E --> H[SQL Injection Report]
    F --> I[Latency Analysis]
    G --> J[Missing Docs List]
    H & I & J --> K[Aggregate Results]
    K --> L[Return to Parent]
    C -->|No| M[Handle Directly]
    style A fill:#C2E476,color:#121212
    style E fill:#10312D,color:#F3F1E8
    style F fill:#10312D,color:#F3F1E8
    style G fill:#10312D,color:#F3F1E8

One common problem: CPU usage spikes to 100% when spawning too many subagents simultaneously. Claude tries to parallelize aggressively, which is great for speed but can overwhelm modest hardware. Limit concurrency in your .claude configuration or implement explicit concurrency controls in your orchestration layer.

The SDK also includes automatic context compaction. For very long-running operations, it summarizes older parts of the conversation to prevent token exhaustion. You don't need to implement this—it happens automatically—but understanding it helps you design better prompts.

Agents that handle hour-long analysis tasks without crashing can charge premium pricing. Reliability is a feature customers pay for.

What Are the Critical Mistakes That Cost You Customers?

Every crashed agent is a churned customer. Every silent failure erodes trust. Here are the mistakes that kill production agents—and how to avoid them.

Mistake	What You'll See	The Fix
No tool time limits	Runaway processes, hung requests	Wrap every tool handler in a 5-second timeout
Full history on every call	Token exhaustion mid-task	Use conversation summaries + selective retrieval
No streaming backpressure	UI freezes, stalled responses	Flush SSE/websocket frames explicitly
Hardcoded agent prompts	Can't update without redeploy	Store agent templates in a config service
No verification layer	Silent failures, wrong outputs	Add rules-based + visual feedback loops
Single model dependency	Outages cascade to users	Route fast tasks to Haiku, complex to Sonnet

flowchart LR
    A[Mistake] --> B[Agent Crash]
    B --> C[Customer Sees Error]
    C --> D[Support Ticket]
    D --> E[Trust Erodes]
    E --> F[Churn]

    G[Timeout Wrappers] -.->|Prevents| B
    H[Verification Layer] -.->|Prevents| C
    I[Monitoring] -.->|Catches| D
    style A fill:#EF4444,color:#FCFCFB
    style F fill:#EF4444,color:#FCFCFB
    style G fill:#AACF57,color:#121212
    style H fill:#AACF57,color:#121212
    style I fill:#AACF57,color:#121212

The most insidious mistake: marking features complete without end-to-end testing. Agents will confidently report "task complete" while the feature is actually broken. Without verification—whether that's automated tests, visual checks, or LLM-as-judge evaluation—you're shipping silent failures.

Permission sprawl is the fastest path to unsafe autonomy. Treat tool access like production IAM: start from deny-all, allow only what each agent needs, require explicit confirmations for sensitive actions, and block dangerous commands entirely.

One person on the Anthropic community described their experience:

"We deployed an agent that could run Bash commands for our internal tooling. Worked great in dev. In production, a weird edge case triggered git reset --hard on a customer's repo. Three hours of their work, gone. Now every destructive command requires human approval, no exceptions."

Each security hole is a lawsuit waiting to happen. Each crashed agent is a support ticket. Each silent failure is revenue walking out the door. Build verification into every agent from day one.

How Do I Deploy My Agent to Production This Weekend?

An agent sitting on your laptop earns $0. You need it live, in front of customers, collecting feedback and proving value. Here's the fastest path from "working locally" to "deployed and demo-ready."

The proven stack for a weekend deploy:

┌─────────────────────────────────────────────────────────┐
│                     Your SaaS                           │
├─────────────────────────────────────────────────────────┤
│  Next.js Frontend                                       │
│  ├── /app/api/agent/route.ts  ← Claude Agent SDK       │
│  └── /app/dashboard           ← User interface          │
├─────────────────────────────────────────────────────────┤
│  Database (Postgres)                                    │
│  ├── Sessions table (agent state)                       │
│  └── Results table (outputs)                            │
├─────────────────────────────────────────────────────────┤
│  Vercel                                                 │
│  ├── Edge Functions (API routes)                        │
│  └── Cron Jobs (scheduled agents)                       │
└─────────────────────────────────────────────────────────┘

Here's a minimal API route that streams agent responses to your frontend:

// app/api/agent/route.ts
import { query } from "@anthropic-ai/claude-agent-sdk";
import { NextRequest } from "next/server";

export async function POST(req: NextRequest) {
  const { prompt, sessionId } = await req.json();

  const encoder = new TextEncoder();
  const stream = new ReadableStream({
    async start(controller) {
      for await (const message of query({
        prompt,
        options: {
          allowedTools: ["Read", "Glob", "Grep"],
          resume: sessionId,
          permissionMode: "bypassPermissions"
        }
      })) {
        controller.enqueue(
          encoder.encode(`data: ${JSON.stringify(message)}\n\n`)
        );
      }
      controller.close();
    }
  });

  return new Response(stream, {
    headers: { "Content-Type": "text/event-stream" }
  });
}

flowchart TD
    A[User Browser] --> B[Next.js on Vercel]
    B --> C[API Route: /api/agent]
    C --> D[Claude Agent SDK]
    D --> E[Built-in Tools]
    D --> F[MCP Servers]
    C --> G[Postgres Database]
    G --> H[Sessions Table]
    G --> I[Results Table]
    style B fill:#121212,color:#FCFCFB
    style D fill:#C2E476,color:#121212
    style G fill:#10312D,color:#F3F1E8

The critical deployment gotcha: rate limiting. Without it, one eager user can exhaust your entire monthly API budget in an hour. Add request limits per user, per session, and per time window before you go live.

Feature-flag new capabilities per tenant. When you add a new tool or integration, roll it out to beta users first, validate it doesn't break anything, then expand. This saves you from deploying a bug to 100% of customers simultaneously.

Add monitoring from day one. Plug SDK hooks into your observability stack—Datadog, OpenTelemetry, whatever you're already using. Capture tool latency, token usage, error rates. You can't improve what you don't measure, and you definitely can't debug production issues without logs.

A deployed agent is a demo-able product. Demo-able products close deals. Get it live, then iterate.

You now have everything you need to build production AI agents with the Claude Agent SDK. But building the right agent—one that customers actually pay for—requires more than code. It requires clarity on what to build and why.

BrainGrid transforms your product ideas into AI-ready specifications, breaking complex features into tasks that agents can execute. Stop guessing. Start shipping.

Originally published on the BrainGrid blog.

Claude Code MCP Servers: Setup Guide + Best Servers (2026)

Nico Acosta — Wed, 01 Jul 2026 11:13:11 +0000

You're pasting logs, docs, or snippets of data into Claude Code. Again.

Every question about your system means manual context. Tab switching. Re-explaining decisions. Copying the same information from one tool to another. It works - but the friction adds up fast.

This isn't a Claude Code problem.
It's a context problem.

Out of the box, Claude Code only knows what's in your repository and what you paste into chat. Your database, designs, GitHub PRs, APIs, and internal docs don't exist unless you explain them — repeatedly.

What if Claude Code could query your database, read designs, and understand GitHub on its own?

That's exactly what Claude Code MCP enables — and it takes about 5–10 minutes to set up.

MCP (Model Context Protocol) lets Claude Code connect directly to the rest of your stack through MCP servers. Instead of guessing schemas, Claude can ask. Instead of placeholders, it fetches real data. Remove the context bottleneck, and Claude Code finally feels like the agent you expected.

What is MCP in Claude Code?

MCP (Model Context Protocol) is an open standard that lets AI tools like Claude Code connect to external systems in a structured, reliable way.

The simplest mental model is:

MCP is an API layer for AI agents.

Just like APIs connect frontends to services, MCP connects Claude Code to databases, APIs, internal tools, specs, and more.

With MCP, Claude Code doesn't just receive context — it can request it on demand. No more dumping schemas into prompts or pasting API responses into chat windows.

Anthropic introduced MCP as an open standard, and today there's a growing ecosystem of community and first-party MCP servers.

Why MCP matters?

MCP isn't about making Claude Code “smarter.” It's about reducing context-switching.

When Claude Code can access the same sources of truth you use — databases, repos, specs — you stop re-explaining and start building. This is why database MCPs, Playwright MCP, and spec-driven systems like BrainGrid create so much leverage.

Claude Code without MCP

Without MCP, workflows usually look like this:

Paste schemas
Describe API responses
Re-explain decisions every session

Claude responds, but always with partial or stale context. Every new question reloads the same information.

Claude Code with MCP

With MCP configured, Claude can:

Query live schemas
Fetch API responses
Read structured specs
Pull tool outputs on demand

In short, Claude stops guessing and starts checking.

“AI that sounds smart” vs “AI that understands your project.”

How MCP works?

When you connect an MCP server, Claude Code gains access to a set of tools — actions it can take on your behalf. Think of each tool as a specific capability: "query this database," "fetch this file," or "create this resource."

Here's the flow:

sequenceDiagram
    participant You
    participant Claude Code
    participant MCP Server
    participant External Tool

    You->>Claude Code: "What tables are in my database?"
    Claude Code->>MCP Server: Discover available tools
    MCP Server-->>Claude Code: list_tables, run_query, etc.
    Claude Code->>MCP Server: Call list_tables()
    MCP Server->>External Tool: Query database schema
    External Tool-->>MCP Server: Table list
    MCP Server-->>Claude Code: Formatted response
    Claude Code-->>You: "You have 3 tables: users, orders, products"

The key insight: Claude Code doesn't talk directly to your database, API, or service. The MCP server acts as a translator — exposing safe, well-defined tools that Claude can invoke without needing raw access.

MCP supports multiple transport protocols:

HTTP — recommended for hosted services (most common)
stdio — runs locally as a subprocess (great for dev tools)
SSE — server-sent events (deprecated)

You don't need to understand these internals to get started. Just know that MCP provides a clean, standardized bridge between Claude Code and your tools.

Why Use MCP with Claude Code?

MCP sounds powerful — but is it worth setting up?

If you're already using Claude Code, the answer becomes obvious once you try it.

1. Real-time data access

Without MCP, Claude's answers are only as good as the last thing you pasted.

With MCP, Claude can:

Query live database schemas
Fetch current API responses
Check the real state of services

This alone removes a massive source of bugs and back-and-forth.

2. Native tool integration

MCP makes tools first-class inside Claude Code.

Common MCP servers include:

GitHub (issues, PRs, repo context)
Figma (design metadata)
Supabase (schemas and queries)
Playwright (browser automation)

Claude pulls context directly from the source — no tab switching, no summarizing by hand.

3. Workflow automation

Once multiple MCP servers are connected, Claude Code can:

Read a spec
Check the database
Generate code
Validate it with tests

All in one flow.

This is where MCP stops being “tool access” and starts becoming workflow automation.

4. You stop being middleware

The most immediate win: no more copy-pasting.

No schemas in chat.
No pasted API responses.
No re-explaining the same decisions.

Claude Code MCP removes that friction so the AI works with your tools, not around them.

Top 10 MCP Servers for Claude Code

You don't need dozens of servers to get value. Most teams start with a small, focused set.

Here are 10 of the most useful MCP servers for Claude Code in real workflows.

1. Supabase MCP Server

Query Postgres directly, explore schemas, and write accurate SQL without guessing table names.

Best for: Full-stack developers using Supabase as their backend

This is often the first Claude Code MCP server people install — and for good reason. It completely eliminates schema copy-pasting and lets Claude reason over your actual database structure.

2. GitHub MCP Server

Read pull requests, browse repositories, and pull issue context straight into Claude Code.

Best for: Teams using GitHub for version control

Instead of summarizing PRs or pasting links, Claude can read the code changes itself and reason about what actually changed.

3. Figma MCP Server

Pull design tokens, component specs, and layout details directly from Figma files.

Best for: Frontend developers building from design handoffs

This removes the ambiguity between “what the design says” and “what gets built,” especially when translating designs into real components.

4. Playwright MCP Server

Run browser automation, capture screenshots, and debug UI flows programmatically.

Best for: QA automation and visual testing

The Playwright MCP Claude Code setup is especially useful for validating UI changes without leaving your editor or manually clicking through flows.

5. BrainGrid MCP Server

Turn vague feature ideas into structured requirements and AI-ready tasks.

Best for: AI builders and teams who want spec-driven workflows

BrainGrid's MCP server allows you to access and create requirements, build tasks, and track progress directly from Claude Code. This adds a missing layer on top of MCP with tools like:

Build REQ-123
Create a requirement from this plan
Run an acceptance review on this PR

This is where MCP stops being “tool access” and starts becoming a system.

6. PostgreSQL / MySQL MCP Server

Direct database connectivity for non-Supabase setups.

Best for: Teams running their own databases

If you're not on Supabase, this gives you the same schema-aware benefits without changing your stack.

7. Context7 MCP Server

Fetch always up-to-date library documentation.

Best for: Working with fast-moving or unfamiliar libraries

It's especially useful when official docs lag behind recent releases or when APIs change faster than blog posts do.

8. Filesystem MCP Server

Navigate files, search directories, and understand large project structures.

Best for: Monorepos and complex codebases

Claude Code becomes significantly better at reasoning about where things live and how files relate to each other.

9. Slack MCP Server

Search conversations, pull decisions, and reference past discussions.

Best for: Remote teams with important context living in Slack

This prevents those classic “why did we do it this way?” moments when the answer is buried in a thread from three months ago.

10. Linear MCP Server

Pull issues, update statuses, and connect tasks directly to code.

Best for: Teams using Linear for project management

This keeps planning and implementation tightly connected instead of drifting apart.

How to Add MCP Servers to Claude Code

Let's get practical.

There are two main ways to add MCP servers to Claude Code. Use the CLI for quick experiments, or a config file for shared and repeatable setups.

We'll use BrainGrid MCP as the example.

Option 1: CLI Commands (Quickest)

The quickest way to add an MCP server.

Basic syntax:

claude mcp add --transport

HTTP-based MCP server (most common)

Most hosted MCP servers (including BrainGrid) use HTTP.

claude mcp add --transport http braingrid https://mcp.braingrid.ai

That's it. Claude Code can now talk to BrainGrid.

Stdio-based MCP server (local tools)

Some MCP servers run as local processes via stdio.

claude mcp add --transport stdio airtable -- npx -y airtable-mcp-server

Important: The -- matters.
Everything after it is passed to the server process, not the Claude CLI.

Windows note: If you're on Windows, wrap the command like this:

cmd /c npx -y airtable-mcp-server

Option 2: Configuration File (Recommended for Teams)

For shared codebases, use a config file to keep MCP setup consistent across machines.
Create .mcp.json in your project root.

Basic structure

{
    "mcpServers": {
        "braingrid": {
            "transport": "http",
            "url": "https://mcp.braingrid.ai"
        }
    }
}

Claude Code automatically reads this file when the project opens.

Environment variables (recommended)

Avoid hardcoding secrets by referencing environment variables.

{
    "mcpServers": {
        "github": {
            "transport": "http",
            "url": "https://mcp.github.com",
            "headers": {
                "Authorization": "Bearer ${GITHUB_TOKEN}"
            }
        }
    }
}

Supported formats:

${VAR} — required
${VAR:-default} — fallback

This is the safest and cleanest way to handle tokens.

Understanding Configuration Scopes

This part confuses a lot of people, so let's make it simple.

Each MCP server can be defined at different scopes:

Scope	Location	When to use
Project	`.mcp.json`	Shared servers like databases, specs, or CI tools
User	`~/.claude.json`	Personal tools you want in every project

Scope precedence

If the same server is defined multiple times, Claude Code uses this order:

Project > User

Quick Setup: BrainGrid MCP (End-to-End)

Let's put it all together with a real setup.

Step 1: Add the server

claude mcp add --transport http braingrid https://mcp.braingrid.ai

Step 2: Authenticate (if prompted)
BrainGrid uses OAuth. Claude Code will open a browser to complete login.

Step 3: Verify the connection

Inside Claude Code, run:

/mcp

You should see braingrid listed as an active server.

Step 4: Test it
Ask Claude Code to list BrainGrid projects or create a sample requirement.
If it returns real data, your MCP setup is working.

Once you've added one MCP server, the rest follow the same pattern.
From here on, Claude Code fetches context on demand — no more manual copy-pasting.

Troubleshooting Common MCP Issues

If MCP doesn't work on the first try, you're not doing anything wrong.

Most Claude Code MCP issues come down to connectivity, authentication, or output limits. The good news: almost all of them are easy to fix once you know where to look.

Server Not Connecting

This is the most common setup issue.

Step 1: Check if Claude can see the server

Inside Claude Code, run:

/mcp

If the server doesn't appear, Claude isn't loading it at all. That means the issue is configuration-level, not runtime.

Step 2: Verify the URL or command

For HTTP-based servers:

Confirm the URL is correct and reachable
Try opening it in a browser or via curl
Check for typos or trailing slashes

For stdio-based servers, re-check the command passed after --.

Step 3: Check network restrictions

VPNs, proxies, and corporate firewalls often block MCP traffic.

Try:

Temporarily disabling your VPN
Switching networks
Allowlisting the MCP server domain

This is especially common with hosted MCP servers.

Step 4: Increase the timeout (for slow startups)

Some servers take longer to respond, especially on first run.

export MCP_TIMEOUT=10000

Authentication Failures

Authentication issues are the most common reason MCP “half works” — where the server appears but returns no real data.

OAuth-based servers (e.g. BrainGrid)

Run /mcp in Claude Code
Click the server name
Complete the browser login flow

If you recently changed accounts or permissions, re-authentication is often required.

Common BrainGrid fix:
Disable and re-enable the server to trigger a fresh auth flow.

API key–based servers

Confirm environment variables are set
Restart Claude Code after exporting variables
Avoid hardcoding secrets in .mcp.json

Quick check:

echo $GITHUB_TOKEN

If it prints nothing, Claude can't use it either.

Output Truncated Errors

Partial responses usually mean you've hit an output limit.

Increase the limit

export MAX_MCP_OUTPUT_TOKENS=50000

Notes:

Warning threshold: ~10,000 tokens
Default hard limit: ~25,000 tokens

Reduce request size

MCP works best with focused queries, not large dumps.

Filter rows
Limit fields
Ask for summaries instead of raw data

Smaller requests are faster and more reliable.

Stdio Server Won't Start

This mostly affects local tools — especially on Windows.

Windows fix (very common)

Wrap npx commands like this:

cmd /c npx -y <server-name>

Without this, Claude Code may fail silently.

Other checks

Confirm the package exists:

  npx <server-name> --help

Verify required environment variables
Ensure Node.js is installed and in your PATH

If the process exits immediately, it's usually a startup or environment issue.

BrainGrid MCP + Claude Code: Spec-Driven Development

Once you have MCP working in Claude Code, the next real unlock is spec-driven development — and this is where BrainGrid MCP truly shines.

Instead of prompting Claude with half-formed ideas and fixing things as context inevitably gets lost, BrainGrid gives your AI a persistent map: requirements, acceptance criteria, and tasks that stay consistent across your entire coding session.

This is the shift from “AI helping you code” to “AI helping you build.”

6.1 Why Spec-Driven Development Matters

Most AI coding breaks down for one simple reason:

There's no shared source of truth.

When you code without a spec:

Context gets lost across prompts
Requirements drift mid-implementation
You end up re-explaining decisions and reworking code

Spec-driven development flips this completely.

You define what you want once, in a structured format, and let the AI reference that spec throughout the build — across files, tasks, and iterations.

Think of it as:

AI coding with a map, instead of coding blind.

If you want a deeper dive into the philosophy behind this, we've written more about it here:
👉 Spec-Driven Development: Ship Reliable Software Faster with AI

6.2 Setting Up BrainGrid MCP

Before jumping into Claude Code, you'll need to set up BrainGrid itself.

Step 1: Create a BrainGrid account

Go to BrainGrid AI Dashboard and sign up
Connect your GitHub account
Select the repository you're actively coding in

This allows BrainGrid to understand where the work is happening and keep requirements tied to real codebases — not abstract ideas.

Step 2: Connect BrainGrid to Claude Code via MCP
For a visual walkthrough, refer to the Quick Setup: BrainGrid MCP (End-to-End) section above.

Add the BrainGrid MCP server to Claude Code:

claude mcp add –transport http braingrid https://mcp.braingrid.ai

Once added:

Run /mcp inside Claude Code
Verify that braingrid appears in the connected servers list
BrainGrid will prompt you to authorize via OAuth
Complete the authorization flow

Claude Code and BrainGrid are fully connected.

6.3 BrainGrid MCP Workflow

BrainGrid MCP follows a simple three-phase spec-driven workflow.
You'll often see this workflow described using shorthand like specify → break down → build — not as rigid commands, but as a way to describe how intent flows through the system.

1: Turn an Idea into a Requirement

Start with a rough idea, directly in Claude Code:
“Create a requirement in BrainGrid to Add role-based access control to the admin dashboard”

Claude, powered by BrainGrid MCP, converts this intent into a structured requirement with:

Clear description
Acceptance criteria
Constraints and assumptions

This is no longer a vague prompt. It becomes your product requirements document — a single source of truth.

Once done, head over to the BrainGrid AI Dashboard. There, you can further refine it by working with the BrainGrid requirements agent. You can give instructions like:
"Help me refine this requirement and ask any clarifying questions."

This helps improve clarity, fill in gaps, and capture details you might have missed.

2: Break the Requirement into Tasks

Once the requirement exists (for example, REQ-123), it's refined and broken down — typically via the BrainGrid app — into concrete, implementable tasks.

From the dashboard, click “Break down requirement into tasks.” BrainGrid will generate a list of actionable tasks tied directly to the requirement.

Each task is scoped tightly enough for focused AI-assisted implementation, without guesswork or oversized prompts. You can fetch any task directly from Claude Code.

3: Build with Full Context

Now comes the real magic.

Pull everything into Claude Code and run:

Build REQ-123

This builds the full requirement with all its context loaded. Claude now has access to:

The original requirement
Acceptance criteria
A complete task list
Review Acceptance Criteria

Each task becomes a high-signal, guided coding session instead of a guessing game.

Why This Changes Everything

With BrainGrid MCP, Claude Code isn't just responding to prompts.

It's working against a living spec.

That means:

Less rework
Fewer clarification loops
More predictable output
Cleaner handoff between planning and implementation

This is the difference between AI-assisted coding and AI-driven development.

👉 Try BrainGrid for free at braingrid.ai and experience spec-driven development inside Claude Code.

Frequently Asked Questions

Does Claude Code support MCP prompts?

Yes. Claude Code fully supports the Model Context Protocol (MCP) specification, including both tools and resources exposed by MCP servers. This allows durable, reusable context across an entire coding session.

What is the MCP configuration format?

Claude Code uses JSON-based MCP configuration files. Each server defines a transport (http or stdio), a URL or command, and optional headers or environment variables for auth.

Does MCP use HTTP?

Yes. MCP supports multiple transports:

HTTP (recommended)
stdio (for local tools)
SSE (deprecated)

Most hosted MCP servers, including BrainGrid, use HTTP.

How is Claude Code MCP different from Cursor MCP?

Both implement the same MCP standard. The difference is setup: Claude Code uses CLI commands and config files, while Cursor uses a settings UI. MCP servers work across both.

Start Connecting Your Development Stack

MCP helps Claude Code work with your existing development tools — so it understands your code, your data, and what you're trying to build.

You don't need to connect everything at once. Start small with two or three MCP servers that map directly to how you already work:

GitHub for code, pull requests, and issues
Your database or backend service for live schemas and data
BrainGrid for structured requirements and specs

This is where the real shift happens.

With a spec-driven workflow, you stop re-explaining decisions and start building with AI that stays aligned — from the first idea to the final commit.

Teams that ship faster aren't writing more code.
They're giving their AI better context.

MCP is how you do that.

Originally published on the BrainGrid blog.

Windsurf vs Cursor 2026: Full Comparison for AI Coding

Nico Acosta — Tue, 30 Jun 2026 11:12:36 +0000

You have more product ideas than hours in the day. AI coding tools like Windsurf and Cursor promise to turn your vision into working code—but which one actually ships faster?

Both are VS Code forks with AI superpowers. Both cost roughly the same ($15-20/month). We tested them head-to-head on the same feature to find out which delivers better results.

This guide walks through the key differences between Windsurf and Cursor, with real test results to help you choose the right tool for your workflow.

What Are Windsurf and Cursor? What are they used for?

Both Cursor and Windsurf are Agentic AI code development tools. They allow developers to use natural-language prompts to generate, modify, and refactor code.

Unlike tools such as Claude Code or GitHub Copilot - which run as extensions inside an existing code editor - Cursor and Windsurf are standalone IDEs (Integrated Development Environments). Both are forks of VS Code, meaning that they replace the need for another IDE, but retain a look and feel familiar to those who have used VS Code in the past.

Both of the tools are inexpensive, Cursor is $20/month and Windsurf comes in at $15/month.

The difference between Cursor and Windsurf comes from how the agents work with prompts.

Cursor is IDE-first, AI Agent second, focusing on assisting developers write code, where the developer is in control of the process.
Windsurf is AI Agent first, and IDE-second. Windsurf aims to take care of the coding autonomously, planning and executing changes with minimal developer intervention.

If you are vibe coding - handing off ideas and letting the agent build - you might find that Windsurf is the better tool. If you are a developer looking for AI assistance while still holding precision control over your codebase, you might find the results from Cursor easier to work with.

What do Cursor and Windsurf lack?

While both Cursor and Windsurf can write code, they both lack the ability to create detailed requirements prior to building the code. As a result, the prompts used to implement the requirement lack detail, and it may require multiple rounds of iteration with different prompts to obtain the desired result.

The Agents need a product manager to help narrow down the requirements and create tasks that can then be implemented by the agents.

Luckily, BrainGrid is available as an MCP (Model Context Protocol) for both Cursor and Windsurf. MCPs provide AI Agents with additional external contexts. These contexts (APIs, databases, tasks) give the agents further detail and insight that results in code that is more resilient, and more likely to work seamlessly with the full codebase, and the external tools it interacts with. To learn more about how MCPs enhance AI Agents, read our recent post Cursor MCP Servers: Complete Setup Guide for AI-Powered Development

We will use the BrainGrid MCP to build a requirements document and create a set of task prompts that can be implemented by AI Agents to add dark mode to the popular open source repository Formbricks.

Using BrainGrid, we ask for a feature to be added (in this case, "Add dark mode to the service") and BrainGrid begins by asking clarifying questions that help better define what the final product will look like. For example:

What parts of the application should support dark mode?

How should users switch between light and dark mode?

BrainGrid acts as the product manager for development—the questions help focus the scope of changes. Neither Cursor nor Windsurf do this out-of-the-box. Sometimes these questions surface new features (like a toggle switch), but that often improves the final result.

The BrainGrid requirement can be turned into tasks that are easily picked up by both Windsurf's and Cursor's AI Agents to build the code.

In the case of adding dark mode to Formbricks, BrainGrid came up with 9 tasks that must be completed:

With these tasks in hand, we can use Cursor and Windsurf to implement the feature.

Which One is Better: Cursor or Windsurf?

Both Cursor and Windsurf supply similar backend LLM models for writing code. The results are generally very similar, so which tool is better will generally fall on the way your team works.

If you are a single developer building code, focusing on the local context of your code - Cursor is easier and faster to work with.
If building on complex codebases, and collaborating with your team, Windsurf might be the better choice.

But, perhaps you'd want to see a real life showdown on adding a feature to an existing codebase. Let's use the tasks created by BrainGrid, and see what Cursor and Windsurf produce.

The Workflow Showdown

With requirements and tasks prompts created, we can apply them to both Cursor and Windsurf to see which better applies our requirement - adding dark mode to our service.

In order to leverage the BrainGrid MCP, it must be installed via the instructions in the documentation.

To leverage the BrainGrid requirements, we simply ask the agent to build the tasks in Req-1. The Agent 'knows' that means BrainGrid, and uses the BrainGrid MCP to connect to BrainGrid and retrieve the tasks.

Cursor

Cursor read in the 9 tasks, and proceeded to complete them, one after another. After completing 3 tasks, it provided an update with details on how the previous three tasks had been completed. It repeated this again after 6 tasks (For a total of 2 requests to continue.)

Once complete, the code had two compilation bugs. With the error supplied to Cursor, they were quickly addressed. Once up and running, it is clear that, while the dark mode is not complete, it had made pretty good progress (estimated about 80% complete).

If continuing with this feature, the next steps would be to ensure that:

All of the boxes are in dark mode.
make the mode button easier to see in dark mode (it is hidden in the upper right).
Update the logo image to work better in dark mode.

Windsurf

Windsurf required a little prompting help to connect to BrainGrid, but ultimately found the 9 tasks to build.

Windsurf's process involved a lot more feedback, making it feel like the process took much longer. For example, Windsurf asked if it should continue after editing each HTML component. There are several dozen HTML components in the Formbricks code, feeling very repetitive (pasting "yes" into the chat window over and over).

Once Windsurf called the job complete, and small compilation bugs were resolved: there was no button to manually switch between light and dark mode (a feature specified in Task 2).

With some additional prompting, the switch was added inside the user settings, but initially the toggle only applied dark mode on the user settings.

With additional prompting, Windsurf was able to get to a point similar to where we stopped with Cursor

Windsurf eventually got to a similar place as Cursor, but it took many additional prompts to ensure the tasks (marked as completed in BrainGrid) were actually completed.

TL;DR Cursor vs. Windsurf

Asking Cursor and Windsurf to complete the same tasks on the same codebase provided very different results.

Both Cursor and Windsurf had minor compilation bugs that needed fixing before the code would load. Both tools fixed these quickly.

However, once the pages loaded, it was clear that the Cursor implementation was much closer to the requirements created in BrainGrid. Windsurf's initial "code complete" had no way to change into dark mode, and none of the page was rendered in dark mode.

Out of the box, Cursor was about 80% of the way to a full dark mode implementation. Windsurf's code was 100% light mode without a toggle. Additional prompting was needed to add the toggle, and then more prompting to get all components to appear in dark mode (after manually approving each component through the development process).

Making the Choice: Cursor vs. Windsurf

Choose Cursor if you want more control over each code change and prefer faster iteration on smaller tasks. In our test, Cursor delivered 80% of the feature in a single pass with minimal prompting.

Choose Windsurf if you prefer a more autonomous AI that plans and executes on its own—just know you may need patience for confirmation prompts on larger codebases.

Either way: Pair your tool with BrainGrid to create detailed requirements first. Our test showed that clear task prompts help both tools deliver better results. Without requirements, you'll waste time re-prompting and debugging code that missed the mark.

FAQ

Which one is better, Cursor or Windsurf?

Many teams have found success with both. In our test, Cursor came closer to the desired outcome than Windsurf. But your mileage may vary—your workflow may work better with Windsurf's more autonomous approach.

Is Cursor cheaper than Windsurf?

Windsurf is $15/month; Cursor is $20/month. The $5 difference is minimal compared to the time you'll save picking the right tool for your workflow.

What are Cursor and Windsurf used for?

Both are AI-powered development environments that help you write, modify, and refactor code using natural language prompts. They're especially useful for shipping features faster when you're not a full-time engineer.

Originally published on the BrainGrid blog.

Cursor MCP Servers: Setup Guide + Best Servers List (2026)

Nico Acosta — Mon, 29 Jun 2026 11:12:08 +0000

"If you give a man a hammer, everything looks like a nail."

Cursor is an IDE with built-in AI tooling. The tooling is extremely powerful, and it can get the job done. But one AI tool alone eventually runs into limitations. You find yourself fixing boilerplate code to match reality, or copying and pasting values into your code.

Just as you wouldn't renovate a kitchen with just a hammer, relying only on Cursor will limit your ability to develop code quickly. Luckily, adding new tools to your Cursor toolbelt is easy: MCP turns Cursor from a single tool into a fully equipped workshop.

Without MCP, Cursor works with the text and the code that are provided in your repo. It has no visibility outside of that code, meaning that Cursor has a strictly one-sided view of how the code interacts with APIs, database, or any other external tool. With MCP servers, Cursor can query your database, read your Figma designs, and help you build requirements and tasks using real external content.

What is a Cursor MCP Server?

MCP is a Model Context Protocol. Cursor uses a large language model to write and reason about code. MCP is the protocol that adds additional context to the model - helping it better understand contexts that live outside the codebase. MCP servers allow Cursor to retrieve live information from external services instead of relying on assumptions.

MCP servers act as bridges between Cursor and external services. When writing code, Cursor can use this bridge to ensure that the code properly interacts with database tables, or parses the correct output from an API response - instead of adding placeholders that must be updated manually.

MCP Advantages

Connecting MCP server gives Cursor visibility beyond the code in your repository. Without this visibility, the model might invent placeholders that don't match your APIs, or define database schemas differently from what already exists. When the model works from actual system data, you spend less time correcting assumptions and replacing boilerplate. Instead, the connections just work.

Leveraging MCP servers in Cursor provides superpowers to Cursor. With vision and context beyond the codebase, the code generated by Cursor is more likely to be immediately useful - improving developer productivity and quality.

Now that you understand why MCP matters, let's look at which servers are worth installing.

Top MCP Servers for Cursor

NOTE: MCP servers are not a HTTP service running on a port that is accessed by the LLM (a server). In the parlance of MCP, a server just means "the thing that provides the tool." It may be a hosted API, a local process, or a CLI-backed integration.

Databases
- Supabase MCP Server - Query your Supabase Postgres directly, explore schemas, write queries.
- PostgreSQL/MySQL MCP Servers - Like Supabase - direct connectivity to databases.
Issue management
- GitHub - Read PRs, check issues.
- Linear - Pull issues, update status, connect code to tasks
Design and Communication
- Figma MCP Server - pull component specs, layouts and designs from the source.
- Slack MCP server - query conversations about issues, and designs for added context.
Documentation
- Context7 - reads in documentation - giving the model more details about external tooling.
Spec-Driven Development
- BrainGrid - Create requirements, and turn requirements into structured tasks

Ready to connect your first MCP server? Let's walk through the setup process.

Cursor MCP Setup Guide

Cursor provides a directory of available MCP servers, each with a link to directly install into your local instance of Cursor. For the BrainGrid MCP, you can install from the Braingrid Documentation

On clicking the "Add to Cursor" button, the MCP server is installed into Cursor:

Each MCP then needs to be authenticated, and given permission for the service.

Once installed, you can see all of the permissions that Cursor has with Braingrid:

BrainGrid works better when you have the CLI and MCP installed. In your terminal:

npm install -g @braingrid/cli
braingrid login

Follow the login steps in your browser, then run:

braingrid init
braingrid setup cursor

This connects BrainGrid to your project, and enables the Cursor integration.

JSON installation

Cursor saves MCP configurations inside your repo in the .cursor/mcp.json file. You can add your own MCP connection by adding the required JSON. The below code connects to a local MCP server with an API key. Complete instructions on connecting via JSON (and instructions on how to make your own "Add to Cursor" button) can be found in the Cursor Docs

{
  "mcpServers": {
    "server-name": {
      "url": "http://localhost:3000/mcp",
      "headers": {
        "API_KEY": "value"
      }
    }
  }
}

With MCP servers connected, let's see how this works in practice with a real example.

BrainGrid MCP and Cursor: Spec Driven Development

Here's where MCP becomes a game-changer for shipping faster. Instead of writing long prompts explaining what you want to build, BrainGrid turns vague feature ideas into structured specs and implementation tasks. When Cursor connects to BrainGrid via MCP, it can read those specs directly and build the feature—no copy-pasting requirements into prompts.

Let's walk through a real example. We'll use the BrainGrid dashboard to create a requirement, then let Cursor execute the implementation tasks.

We will extend our Next.js ToDo App to add Supabase database storage for each todo.

BrainGrid, as a project management tool, helps you clarify the requirements. For example, it asked what additional data points should be added to the ToDo app. The suggestions were good, so I asked for them to be added to the requirements.

After several minutes, BrainGrid comes up with a requirement.

This document describes the problem, and what must be completed to create a solution. It goes on to have acceptance criteria, describing the work that must be completed to consider the specification completed. Once this is accepted, we ask BrainGrid to create the tasks and prompts that are needed to do the work. After a few more minutes we have these tasks.

With these tasks completed, we can switch to Cursor, and just ask it to complete the tasks that BrainGrid has created. The tasks were a part of Proj-3, Req-6, so by typing

```bash Cursor
/build proj-3 req-6




Cursor can access BrainGrid through the MCP, read the prompts and implement the code.

## Start Shipping Faster Today

Cursor is already powerful. MCP makes it dangerous (in a good way).

Without MCP, Cursor guesses at your database schema, invents API responses, and forces you to fix boilerplate. With MCP, Cursor queries your real systems and writes code that actually works the first time.

**Your next steps:**

1. **Install one MCP server** for a service you already use—[Supabase](https://cursor.com/docs/context/mcp/directory), GitHub, or Figma are great starting points
2. **Try [BrainGrid](https://app.braingrid.ai)** to turn your next feature idea into AI-ready tasks that Cursor can build reliably via `/build`
3. **Browse the full directory** at [Cursor's MCP list](https://cursor.com/docs/context/mcp/directory) to find more integrations

Stop copying and pasting. Let MCP connect your tools so you can focus on shipping.

## Frequently Asked Questions about Cursor MCP Servers

#### What is MCP in Cursor?
MCP provides Cursor with more context, by connecting external tools that the codebase may reference, or tools that reference the code (issues, designs, requirements).

#### How do I add custom MCP servers to Cursor?
Many services have implemented a "Add to Cursor" button that takes care of all your configurations. Manual addition of MCP servers is done via the Cursor settings panel or via a JSON file in the `.cursor` directory.

#### What is the MCP configuration format?
The JSON format includes the name, connectivity and routes required to connect to the MCP server.  Details can be found in the [Cursor Docs](https://cursor.com/docs/context/mcp#using-mcpjson)
A GitHub MCP configuration might look like:


```json
    "github": {
      "type": "http",
      "url": "https://mcp.github.com",
      "headers": {
        "Authorization": "Bearer ${GITHUB_TOKEN}"
      }
    },

Does MCP use HTTP or stdio?

Cursor MCP uses both. Stdio is recommended for local tools, while http is recommended for remote connectivity.

How do I authenticate MCP servers in Cursor?

Most hosted MCP servers use OAuth, where the user logs in with a browser. For local, or API based MCPs, API keys or tokens can be used.

Where is the Cursor MCP config file?

The config file is saved in the .cursor directory of your repository.

Does Cursor support MCP prompts?

Yes. MCP servers can provide both tools (actions) and resources (data). Cursor supports the full MCP specification including prompts.

What transport protocols does MCP support?

MCP supports two transports: HTTP (recommended for remote servers) and stdio (for local tools). HTTP is the modern standard.

What are common MCP issues? How do I troubleshoot?

The trickiest part of using MCP servers is getting the initial connectivity working, and is most likely to occur when creating a JSON connection to Cursor. Once auth, tokens, and environmental values are correctly set, Cursor works seamlessly with the MCP servers.

Originally published on the BrainGrid blog.

How to Migrate Your Lovable App to Next.js (Full Guide)

Nico Acosta — Sun, 28 Jun 2026 11:14:26 +0000

AI agent tooling has allowed entrepreneurs with no coding knowledge to build complete SaaS products. But eventually, you hit a limit, and need to find other ways to improve your application and build new features that are beyond the scope of some AI coding tools.

In our first post on downloading Lovable projects, we walked through the steps to export your Lovable application into GitHub. Now that it is in GitHub, we can use additional AI tools to improve and add features - growing your application to its full potential.

In this post, we will migrate our Lovable application from a client side React App to a full-stack Next.js App. We will use BrainGrid and Claude Code to complete this code migration.

Why migrate code we just wrote to a different framework?

This is a great question. Lovable apps are built with the React framework - a very popular JavaScript framework for building applications. But it has some drawbacks, including:

React pages are built on the browser, so the first load is always slow - a lot of JavaScript code has to be downloaded to get your page to work. Slow pages can lose customers.
Poor search engine optimization. If the bot only sees the empty page (the content loaded too slowly), you won't be indexed by Google, ChatGPT or any other search engine out there.
Did you optimize your images? React sends your raw images to the browser. There's no server optimization - leading to slow page loading.

Think of Next.js as a supercharged React. It offers all of the advantages of React, but also does most of the work on the server. This means:

No huge JS download.
Optimized content for search engines and LLMs
Image optimization out of the box.
Development is easier.

The last bullet might not seem important, but if development is easier for human developers, it certainly is easier for AI code assistants as well. By migrating our application to Next.js, we will streamline future development, and also make the application faster, and have better SEO. It's a win/win situation

Using GitHub to copy the code to your computer

This tutorial begins with your Lovable application migrated to GitHub. If you have not yet connected your app to GitHub, this is the first step. We will use a todo app as our example.

Once your application is in GitHub, you'll want to make a local copy. On the GitHub page of your application, click the Green Code button, and copy the URL provided.

We want to clone this repo onto our computer, so that we (by we, I mean the AI agents) can update the code. Open a terminal window to begin the process.

I personally have a GitHub folder on my Mac to organize all my repos in one place. It just makes finding things easier later on.

mkdir Github
cd Github

This command creates a folder (mkdir means “make directory”) called Github, and changes (cd means “change directory”) to that directory. Now we are ready to clone the application. (You'll need to change the URL to the GitHub link for your application, or just use this one to follow along)

git clone https://github.com/dougsillars/chill-todo-vibes.git

This will create a new directory with your code inside it. The output will tell you the name of your folder:

 git clone https://github.com/dougsillars/chill-todo-vibes.git
Cloning into 'chill-todo-vibes'...
remote: Enumerating objects: 95, done.

Change to the directory that your code was “Cloned into.” For example:

cd chill-todo-vibes

This will move into the GitHub directory that I cloned.

You now have made a copy of your application code locally on your computer. Next, we set up your development environment - installing all the tools you'll need to complete the migration. There are a number of steps here, but MANY of these need to be done just the first time to get everything set up on your computer.

Preparing the software

(Or, 30 minutes of downloading all the bits)

To migrate to Next.js, we need prompts to tell Claude Code what steps to take to migrate the application. Since we do not have expertise in React and Next.js, we will use BrainGrid to build the requirements and create the prompts that Claude needs to do the work. Sign up for free at BrainGrid.ai.

BrainGrid and Claude installation

In the terminal, we will install the BrainGrid CLI (Command Line Interface).

If you do not already have NPM (Node Package Manager) installed, install NPM.

With NPM installed, we can use it to install and set up BrainGrid.

npm install -g @braingrid/cli
braingrid login

You'll connect the CLI to your BrainGrid account through the website.

Now, we are ready to connect your project to Braingrid:

braingrid init

Walk through the steps to connect your GitHub repository to BrainGrid. Once that is completed, we will connect BrainGrid to Claude Code. If you do not have a Claude Code account, you can create an account at https://claude.ai/ (note the Claude Code requires a subscription)

braingrid setup claude-code

Installing the Coding Environment

Developers use apps called IDEs (Integrated Development Environment) to write code. To connect your GitHub code to Claude Code, we will use VS Code. If you don't have VS code installed, grab it from the link and install it.

Open VS code, and open a new Window:

Click "Open" and then open the repository you just cloned to your computer. We're now ready to develop on the codebase (with Claude, of course!). To add Claude, click the Extensions button on the left navigation, and search for Claude Code, and install it.

Note that there is no install button on my screenshot, as it is already installed on my computer!

To activate Claude Code in your application press Command-Shift-P, and search for Claude. Open this in a new tab:

Now we have all of our code, and all of the tools installed on our computer, and we are ready to go! The good news is that you only had to do all of this once - now that the tools are here, you can use them over and over for new features in your application.

Finally, time for the migration

In software development, code is built based on the requirements provided to the developers. Requirements describe in detail what features are going to be added, and how that is expected to work. Coding agents are no different - if they don't understand what it is that you are asking them to build, how can they build it correctly?

Once we have requirements, developers break down the work into tasks - the actual work that needs to be done to create the new feature.

We will use Claude and BrainGrid to create the requirements and tasks, and then have Claude Code complete the tasks to create our new Next.js version of the application. BrainGrid is integrated with Claude Code using slash commands ( / followed by a command), so we can use these to continue.

In the Claude tab, we will use the /specify command to tell Claude and Braingrid what we want to do:

Claude will walk you through the steps.

BrainGrid and Claude will reason out the requirements - what are the changes required in the code to make the specification happen.

Through this process, Braingrid/Claude will ask a number of questions and ask for approvals. It will eventually come up with the requirement for the code change:

It will then give you next steps:

Create tasks: We know what needs to be done. This breaks it down into the discrete steps to do the work.
Create a Git branch. Branching allows your original code to remain untouched, and the new branch will have all the code changes. (React -> Next.js)
Build the plan.

In this case, we have 5 tasks that Claude will complete. Claude can print out all of the prompts, or just begin tackling them.

Here is prompt 1 from this project


### TASK-1: Configure Next.js Project Structure and Dependencies

Dependencies: None (start here!) Goal: Replace Vite with Next.js 16+ configuration Key Actions:

1. Update package.json:
   * Remove: vite, @vitejs/plugin-react, react-router-dom
   * Add: next (latest 16.0.7)
   * Update scripts: "dev": "next dev", "build": "next build", "start": "next start"

Create next.config.mjs:
 { appDir: true }

2. Update tsconfig.json:
   * Set jsx: "preserve", module: "esnext"
   * Add "@/*": ["./src/*"] to paths
   * Include Next.js types
3. Delete: vite.config.ts, index.html

Success: No Vite deps, Next.js configured, ready for development

Claude can now begin working through the tasks, and upon completion, provides details on the migration:

On running these commands, we can try out our application (and you can see how my breakfast shopping list is going):

Getting the Application on the internet

It is great that we now have working code in Next.js. But now that we are outside of Lovable, how do we get this application deployed to the internet? Vercel is a common cloud platform for deploying Next.js applications.

Claude completes several GitHub tasks for us. It merges our "branch" of code to the main branch, and "pushes" the code to GitHub, This does mean that our React App is no longer in the GitHub repository - but we don't need it any longer!

Claude installs vercel and completes the steps (you will need to create a Vercel account, and authorize access as part of the process). But once it is finished, we receive a deployment summary.

Visiting https://chill-todo-vibes-hdgv1enhu-doug-sillars-projects.vercel.app/ shows us our production application on the web.

Wrapping up

In this post, we took an existing React application (lovingly created with Lovable) and migrated it to Next.js to improve search indexing and page load times.

We used GitHub to move our code to our local computer, and installed BrainGrid, Claude Code and VS Code to create our AI developer environment. Using this environment, and a few basic commands, we are able to leverage the Requirements generation power of BrainGrid, and the coding talents of Claude Code to easily migrate our code to Next.js, and deploy it on Vercel.

If you're interested in adding SaaS features, creating migrations and more - you too can leverage BrainGrid for your application requirements and task generation, and then pass the tasks to Claude Code to complete the work.

Originally published on the BrainGrid blog.

What Is a Product Management Agent?

Nico Acosta — Sat, 27 Jun 2026 11:13:00 +0000

AI coding tools have changed who gets to build software. A new generation of non-technical founders and domain experts can now turn ideas into working features with tools like Cursor, Claude Code, Replit, and Windsurf. You describe what you want, and the agent writes the code.

But anyone who has tried to build beyond a simple prototype knows the feeling: things start to break.

Features regress. Integrations behave inconsistently. The AI loses track of context. That one small tweak somehow breaks three other parts of the app. You are no longer building. You are firefighting.

The problem is not code generation. The problem is planning.

A Product Management Agent is the missing layer in this new AI stack. It acts like a product manager, systems thinker, and senior engineer working together. It turns messy ideas into clear specifications, breaks large projects into smaller tasks, asks the right clarifying questions, and gives coding agents the direction they need to deliver reliable software.

It is the bridge between human intent and machine execution.

Why AI Coding Breaks Down Without a Product Management Layer

Most AI coding tools behave like very fast junior developers. They are powerful and eager, but they need clarity. Without structure and direction, they make assumptions, lose context, and rewrite things they should not touch.

The symptoms look like this:

A small change breaks features that used to work
The AI starts creating duplicate files or reorganizing code in confusing ways
Complex requirements get misunderstood or oversimplified
Integrations and edge cases fall apart as the app grows

Professional engineering teams solve this with product managers, system design, specs, PRDs, RFCs, and review processes. Vibe coders usually do not have those tools or that experience. They have an idea, an AI coding assistant, and a lot of trial and error.

A Product Management Agent brings that missing discipline into the AI workflow.

What a Product Management Agent Actually Does

A Product Management Agent handles the thinking work that happens before and around code. It takes a builder's idea and transforms it into inputs that AI coding agents can execute correctly.

At BrainGrid AI, we train our Product Management Agent in a set of core skills that mirror what strong product managers and senior engineers do in healthy teams.

1. Systems thinking

The agent learns to see the product as a system, not a collection of isolated features. It considers data flows, ownership, side effects, and how new work fits into the existing architecture. A change to notifications should not silently break permissions or billing.

2. Functional decomposition

Large problems rarely get solved in a single request. The agent breaks big goals into logical, buildable pieces with clear goals and outcomes. This makes it easier for coding agents to stay on track and for builders to review the work step by step.

3. Mapping UX flows

Features are not only technical. They are experienced by users. A Product Management Agent maps user journeys, entry points, success paths, and failure paths so the implementation supports a complete workflow, not just a single screen or endpoint. It thinks about what happens before and after each interaction.

4. End-to-end thinking

A real feature touches more than one layer. It may affect APIs, UI, data models, permissions, validation, error handling, and analytics. The agent learns to think across the entire lifecycle of a feature so that nothing important is left out.

5. Abstraction and simplification

Great engineers hide complexity behind clean interfaces. The agent develops an instinct for when to introduce a new abstraction, when to reuse an existing one, and how to keep the mental model simple for the builder. The goal is power without unnecessary complexity.

6. Architectural intuition without over-architecting

There is a fine line between a solid foundation and over engineering. The agent learns patterns that help apps scale and stay maintainable, but avoids heavyweight solutions that slow down early teams. It aims for just enough architecture, with room to grow.

7. Asking clarifying questions

Most failures in AI coding come from unspoken assumptions. The builder says "add 2FA" and the system needs to know: which users, which flows, what UX, what edge cases, what happens on failure. A Product Management Agent learns to ask targeted clarifying questions at the right time so hidden requirements surface before code is written.

8. Specification writing

All of these skills come together in the ability to write clear, practical specs. A good specification includes goals, context, UX flows, constraints, edge cases, and acceptance criteria. Poor specs produce fragile software. Great specs produce reliable software that is easier to evolve.

These core skills enable effective task planning, sequencing, and review. Once the agent has a good specification, it can:

Break it into well scoped tasks
Create engineering grade prompts with the right context
Define acceptance tests for each task
Validate whether the output from the coding agent matches the intent

In other words, the Product Management Agent creates a stable path from idea to working code.

Why This Matters for AI Builders

AI coding is powerful, but on its own it is still unpredictable. Builders often feel like they are rolling the dice every time they ask for a change in a complex app. A Product Management Agent gives them structure and repeatability.

This matters because:

Features ship faster and with fewer surprises
Less time is spent debugging regressions and strange side effects
The codebase stays understandable and maintainable as it grows
Non-technical founders can build like experienced teams
AI coding tools become more of a reliable partner and less of a gamble

The Product Management Agent is not there to replace coding agents. It is there to guide them.

Why We Built One at BrainGrid

At BrainGrid, we believe that AI coding tools are only half of the story. The other half is planning, structure, and product thinking. Without that half, non-technical founders get stuck in loops of rebuilds, half broken features, and abandoned projects.

So we built the Product Management Agent as the first layer of the BrainGrid platform.

BrainGrid turns ideas into specs, plans features, maps UX flows, asks clarifying questions, breaks work into tasks, and generates engineering grade prompts and acceptance criteria. Coding agents then use this structure to build features that are more likely to work the first time and keep working as the product evolves.

Our goal is simple: Make AI coding reliable enough that anyone with a good idea can build a real product.

Originally published on the BrainGrid blog.

Spec-Driven Development: Ship Reliable Software Faster with AI

Nico Acosta — Fri, 26 Jun 2026 11:11:46 +0000

You know exactly what your users need—you've lived in their world. But every time you ask Claude or Cursor to build it, you get buggy code that misses the point. The problem isn't the AI. It's the input.

Spec-driven development flips the script: instead of learning to code, you learn to write clear instructions that make AI coding assistants finally work for you. Tools like BrainGrid have emerged specifically to help domain experts capture their knowledge as structured specs—turning vague ideas into AI-ready requirements without engineering expertise.

The founders who master this will ship their first paying feature while others are still debugging tutorial projects.

Why Your AI Keeps Missing the Point

Here's a pattern you might recognize: You describe what you want. Claude generates a bunch of code. It looks right... but doesn't quite work. You refine your prompt. Try again. Three hours later, you're no closer to shipping.

The issue isn't weak AI models—it's that we've been treating them like search engines rather than careful partners. As GitHub's team puts it:

"AI excels at pattern completion, but not at mind reading."

AI coding assistants are brilliant developers with amnesia. They need context every single session. When you rely on screenshots, Slack messages, or verbal explanations instead of canonical specs, the AI loses context after a few turns. The result? It starts guessing.

And when AI guesses, it invents things you never defined: copy, schemas, naming conventions, business rules. That's when bugs appear—not because the AI is broken, but because you never told it what you actually wanted.

Compare these two approaches:

❌ Vague prompt: "I need a login page with React"

✅ Precise spec: "Users must sign in with email to view their dashboard. Unauthenticated users are redirected to /login. Show error message 'Invalid email or password' on failed attempts. After 3 failed attempts, show 'Account locked. Try again in 15 minutes.'"

The second version eliminates guessing. The AI knows exactly what to build, including edge cases.

flowchart LR
    subgraph VAGUE["❌ Vague Input"]
        V1["I need a login page"]
    end

    subgraph GUESS["AI Guessing"]
        G1["Invents copy"]
        G2["Assumes schema"]
        G3["Missing edge cases"]
    end

    subgraph BUGS["Bugs & Rework"]
        B1["Doesn't match intent"]
    end

    V1 --> G1
    V1 --> G2
    V1 --> G3
    G1 --> B1
    G2 --> B1
    G3 --> B1

    subgraph PRECISE["✅ Precise Spec"]
        P1["Users, triggers,<br/>outcomes, edge cases"]
    end

    subgraph UNDERSTAND["AI Understanding"]
        U1["Clear requirements"]
        U2["Defined behavior"]
        U3["Known constraints"]
    end

    subgraph SHIP["Working Code"]
        S1["Matches intent"]
    end

    P1 --> U1
    P1 --> U2
    P1 --> U3
    U1 --> S1
    U2 --> S1
    U3 --> S1

Vague prompts lead to AI guessing and bugs. Precise specs lead to working code.

Every hour you spend debugging AI-generated code that missed the point is an hour not spent talking to potential customers. This is exactly why BrainGrid exists—it asks the clarifying questions upfront that prevent AI from guessing. Instead of hoping Claude understands your business logic, you capture it in a structured requirement that any AI coding assistant can execute accurately.

The Domain Expert Advantage You're Not Using

Here's the uncomfortable truth most "learn to code" advice ignores: you already have the hard skill.

You know the "what" and the "why"—the problem users will pay to solve. Engineers only know the "how" (the syntax). As Sean Grove from OpenAI recently noted:

"The person who communicates the best will be the most valuable programmer in the future."

Specifications, not prompts or code, are becoming the fundamental unit of programming.

Your domain expertise—understanding customer workflows, pain points, and what they'll pay for—is the scarce resource. Code is increasingly a commodity produced by AI. Your value is defining the specification that directs that commodity toward a paying problem.

Domain narratives written in plain language give AI better context than technical jargon ever could. When you describe real workflows from your industry, you're providing exactly the kind of rich context that makes AI assistants useful.

Write specs as "user stories with teeth":

Who is the user? (Role, context, goal)
What triggers the action? (Click, time, event)
What should happen? (Visible outcome)
What data changes? (Database, API, state)

Domain experts who write clear specs can delegate implementation to AI—or contractors—without losing intent. No engineering hire required.

BrainGrid was built for this exact persona: domain experts who know what to build but need help translating that knowledge into AI-ready instructions. The /specify command takes your rough idea ("I need user authentication with OAuth") and refines it into a structured requirement with acceptance criteria, edge cases, and success metrics. No engineering background required.

The Four-Phase Spec-Driven Development Workflow

Ad-hoc prompting works for throwaway prototypes. But if you're building something users will pay for, you need a repeatable workflow that eliminates decision fatigue and builds shipping muscle.

The spec-driven development workflow follows four phases:

Specify

Define the user journey, success metrics, and guardrails. Keep it to one page maximum. You're capturing intent, not writing a thesis.

Plan

Let AI derive implementation steps from your spec. This is where architectural decisions get made—stack choices, integration points, constraints.

Tasks

Break the plan into bounded, testable work units. Each task should be something you can implement and verify in isolation.

Implement

Execute tasks one at a time, reviewing each before proceeding. This prevents the "massive code dump with hidden bugs" problem.

Here's a starter spec template you can use immediately:

## Feature: [Name]

**Goal**: One sentence describing the outcome
**User**: Who does this, and why do they care?
**Trigger**: What action starts this flow?
**Happy Path**: Step-by-step what happens when everything works
**Edge Cases**: What could go wrong? How should we handle it?
**Success Metric**: How do we know this feature is working?
**Data**: What gets created, updated, or deleted?

The biggest pitfall? Asking AI for "complete implementation in one conversation." Symptom: massive code dumps with hidden bugs. Fix: Execute in bounded phases, 2-3 tasks at a time.

Each completed phase is a checkpoint where you can pause, test in development environment, or pivot—no sunk cost in abandoned code.

BrainGrid's workflow maps directly to these four phases:

Specify → /specify "your idea" generates a structured requirement with AI refinement
Plan → The requirement includes implementation guidance and acceptance criteria
Tasks → /breakdown REQ-123 breaks your requirement into bounded, AI-ready tasks
Implement → /build REQ-123 gives you the complete task list ready for Claude Code, Cursor, or any AI coding assistant

This isn't just theory—it's a command-line workflow you can start using today.

Iterate on Text, Not Code

Here's a principle that will save you weeks of frustration: changing a paragraph of text takes 30 seconds; refactoring a codebase takes 3 hours.

Get the logic right in English first. Then let AI translate to code.

As Startup House notes:

"Preparing a specification document may seem like a waste of time at first, but it is a necessary step that will save you tons of time in the development phase."

The 30-second edit test:

Before coding any feature, describe it in 3-5 sentences
Read it aloud—does it make sense to someone unfamiliar with your product?
If not, rewrite until clear
Only then paste into your AI coding tool

After coding, ask your AI assistant: "Summarize how each change satisfies the spec bullets." This creates a verification loop that catches drift before it compounds.

The biggest pitfall here? Not updating specs after discovering new requirements during coding. Symptom: Contributors prompt against stale docs and recreate solved problems.

BrainGrid stores your requirements and tasks in a central system—not scattered markdown files. When you discover new requirements during coding, update the requirement in BrainGrid and it becomes the single source of truth. No more prompting against stale docs because the spec lives in one place that everyone (human and AI) references.

Faster iteration means more learning cycles before launch, which means better product-market fit when you do ship.

What Your Spec Must Include (And What It Shouldn't)

Right-sizing specs prevents analysis paralysis while ensuring AI has enough context. The goal is "bare bones" that covers the critical path—not a comprehensive document that takes longer to write than the feature takes to build.

When using spec-driven development, over-verbose specs create a "tedious review burden." You end up reviewing documentation instead of shipping features.

Include:

Goal and success metric
Users and their context
Data contracts (what gets created, updated, deleted)
Guardrails and constraints
Edge cases that matter
Post-launch telemetry (how you'll know it's working)

Exclude:

Detailed wireframes (use napkin sketches instead)
Exhaustive test cases (generate these from specs later)
Implementation details (let AI figure those out)

The "Five W's + H" spec checklist:

Who uses this feature?
What do they accomplish?
When does this trigger?
Where in the product does it live?
Why does this matter to revenue?
How do we know it's working? (success metric)

The pitfall to avoid: Overloading specs with wireframes creates "visual feedback loops" where you endlessly tweak UI instead of shipping logic.

Lean specs let you ship V1 fast, gather real user feedback, then enhance—instead of building features nobody wants.

BrainGrid's /specify command uses AI to ask the right questions—Goal, Users, Acceptance Criteria, Edge Cases—so you capture what matters without over-engineering. The output is structured for AI consumption: not a 50-page document, but a focused requirement that Claude Code or Cursor can execute in bounded tasks.

Common Spec-Driven Development Mistakes (And How to Avoid Them)

Knowing failure modes in advance prevents discouragement and wasted cycles. Here are the mistakes that kill momentum:

Mistake 1: Feature Creep

AI makes it easy to add cool features. "While we're at it, let's also add..." is the enemy of shipping. If it doesn't help users solve the core problem (and pay you), cut it.

Mistake 2: "I'll Know It When I See It"

Building without a plan leads to visual feedback loops where you endlessly tweak UI instead of shipping logic. Fix: Wireframe on a napkin or use a simple drag-and-drop tool before asking AI to code.

Mistake 3: No Success Metrics

Symptom: No one knows if V1 is "good enough" to launch—so you keep adding features instead. Fix: Define what "working" looks like before you write a single line of spec.

Mistake 4: Letting AI Invent Conventions

When you don't define copy, schemas, or naming conventions, AI invents them—inconsistently. Fix: Capture these in your spec upfront, even if it feels tedious.

Mistake 5: Ignoring Rollback Plans

No kill-switch means compliance sign-off takes forever and anxiety stays high. Fix: Define how you'll revert if something breaks.

Pre-flight checklist before every AI coding session:

[ ] Is this feature in my spec?
[ ] Does it help users solve the core problem?
[ ] Do I have a success metric defined?
[ ] Can I test this without the rest of the system?

Every unplanned feature delays your launch date. Discipline to cut equals faster time to first revenue.

BrainGrid prevents these mistakes by design:

Feature creep → Requirements have defined scope; tasks are bounded and trackable
No success metrics → The /specify flow prompts for acceptance criteria before generating tasks
AI inventing conventions → Your requirements capture naming, tone, and data contracts upfront
Stale docs → Central requirement storage means one source of truth, not scattered files

The structure enforces discipline so you don't have to rely on willpower alone.

Your New Role: Chief Spec Officer

The mindset shift that makes spec-driven development stick: you're not learning to code—you're learning to lead AI.

Your role shifts from "tinkering with code" to "shipping products." The spec is your source of truth; the code is just the implementation detail.

As The New Stack puts it:

"The future of software engineering won't be about typing faster—it will be about thinking more clearly."

Human judgment remains essential at every phase:

Does the spec capture what you actually want to build?
Does the plan account for real-world constraints?
Are there omissions or edge cases the AI missed?

The process builds in explicit checkpoints for you to critique what's been generated. The AI generates the artifacts; you ensure they're right.

Weekly spec-driven cadence:

Monday: Review last week's shipped features against specs—did they hit success metrics?
Tuesday-Thursday: Specify → Plan → Task → Implement cycle for this week's priority
Friday: Update specs with learnings, archive completed features, prioritize next week

The pitfall: Going back to "vibe coding" when under pressure. Symptom: Spending a weekend debugging AI output that drifted from intent.

Spec-driven founders ship consistently. Consistent shipping builds user trust. User trust converts to revenue.

BrainGrid is your command center for spec-driven development. Here's the complete workflow:

## Turn vague idea into structured requirement
braingrid specify --prompt "Add OAuth login with Google and GitHub"
## → Creates REQ-123 with acceptance criteria, edge cases, success metrics

## Break requirement into AI-ready tasks
braingrid breakdown REQ-123
## → Generates 5-8 bounded tasks with implementation guidance

## Get the full build plan for your AI coding assistant
braingrid build REQ-123 --format markdown
## → Ready to paste into Claude Code, Cursor, or Windsurf

## Track progress as you ship
braingrid task update TASK-456 --status COMPLETED

This is what "Chief Spec Officer" looks like in practice: you define intent, BrainGrid structures it, AI implements it, you verify and ship.

Start Shipping

Spec-driven development isn't about adding process for its own sake. It's about removing the friction between your expertise and working software.

You already know the problem worth solving. You already understand your users. The only thing missing was a systematic way to translate that knowledge into instructions AI can execute reliably.

Now you have one.

Ready to become a Chief Spec Officer? BrainGrid gives you the spec-driven workflow in one tool—from vague idea to shipped feature. Start with braingrid specify --prompt "your next feature" and see how fast you can go from concept to code.

Stop debugging AI output that missed the point. Start shipping features that match your intent.

Originally published on the BrainGrid blog.

DEV Community: BrainGrid

Claude Code Pricing 2026: Pro vs Max vs Team (Updated June)

How Much Does Claude Code Cost? Quick Overview

API Token Pricing

Claude Pro vs Max: Which Plan Should You Choose?

Claude Code Teams and Enterprise: When Do You Need Them?

How to Reduce Claude Code Costs: Practical Efficiency Strategies

Use /clear between tasks

Use /compact to summarize the conversation

Check your usage with /cost

Configure .claudeignore

Model Selection Strategy

The Biggest Token Saver: Spec-Driven Development

Is Claude Code Worth It? The Solo Founder's Decision Framework

Frequently Asked Questions

How much does Claude Code cost?

Is Claude Code free?

What's the difference between Claude Pro and Max?

Why is Claude Code using so many tokens?

How do I reduce Claude Code costs?

Is Claude Code worth it?

Claude Code vs Cursor: which is cheaper?

What are Claude Code rate limits?

Cursor Pricing 2026: Free vs Pro vs Ultra — Which Plan?

What Cursor Brings to the Table

Hobby Tier: Starting with Cursor

Pro ($20/month): The Sweet Spot for Most Founders

Pro+ ($60/month) and Ultra ($200/month): For Heavy Users

Team and Enterprise plans

Addons: Bugbot

Further extending Cursor: BrainGrid's spec driven development

Wrapping up

FAQ

How much does Cursor Team cost?

How costly is Cursor?

Is Cursor AI free or paid?

Is Cursor better than Copilot?

Do you need a subscription for Cursor?

Is Cursor's free plan good?

How much do different models cost in Cursor?

Ralph Wiggum Plugin for Claude Code: Autonomous Coding Guide

Why "Ralph Wiggum"?

What is the Ralph Wiggum Plugin for Claude Code?

What is an Autonomous Loop in Claude Code?

Why Do We Need This?

The Normal Problem

The Ralph Solution

When to Use Ralph Wiggum Plugin (And When Not To)

✅ Use Ralph For:

❌ Don't Use Ralph For:

How to Install and Use Ralph Wiggum Plugin: Quick Start Guide

Install

Commands

Example: Add Documentation

The Secret: BrainGrid Makes Perfect Prompts

Without BrainGrid

With BrainGrid MCP

The Difference

The Complete Workflow

Ready-to-Use Templates

Feature Implementation

Bug Fix

Quick Tips

Ralph Wiggum Plugin Troubleshooting

Frequently Asked Questions About Ralph Wiggum Plugin

What is the Ralph Wiggum plugin?

How do autonomous loops work in Claude Code?

How do I install the Ralph Wiggum plugin?

What commands does the Ralph Wiggum plugin support?

When should I use Ralph Wiggum plugin?

How much does Ralph Wiggum plugin cost?

Can I use Ralph Wiggum with BrainGrid?

Conclusion

Windsurf MCP Servers: Setup Guide + Best Servers (2026)

What is MCP in Windsurf?

Why MCP Matters for Shipping Faster

How to Set Up MCP Servers in Windsurf

Installing from the MCP Marketplace

Installing MCPs manually with JSON

Windsurf MCP Configuration Format

Use `/clear` between tasks

Use `/compact` to summarize the conversation

Check your usage with `/cost`

Configure `.claudeignore`