Forem: Serenities AI

Developer's Guide to Qwen 3.6 Plus: How to Get Started

Serenities AI — Sat, 04 Apr 2026 10:22:38 +0000

Best Use Cases

Based on benchmark performance and developer reports, Qwen 3.6 Plus excels in:

1. Repository-Level Code Analysis

With 1M tokens of context, most mid-sized codebases fit within a single prompt. Load your entire repository and ask the model to analyze architecture, find bugs, or suggest improvements.

2. Document Parsing and Analysis

Qwen 3.6 Plus leads all models on OmniDocBench v1.5 (91.2), making it the strongest choice for processing complex PDFs with tables and mixed layouts.

3. Visual Coding (UI to Code)

The model can interpret UI screenshots, wireframes, or prototypes and generate functional frontend code.

4. Multi-Step Agent Pipelines

Strong tool-calling (MCPMark 48.2%) and terminal task completion (Terminal-Bench 61.6%) make it well-suited for autonomous agent workflows.

5. High-Throughput Applications

At ~158 tokens/second — roughly 1.7x faster than Claude Opus 4.6 and 2x faster than GPT-5.4 — speed advantage is meaningful for developer tools and batch processing.

Practical Limitations You Must Know

1. Data Collection on Free Tier

The free tier collects your prompts and completions for model training. Do not send confidential data through the free endpoint.

2. Fabrication Rate

Independent testing identified a 26.5% fabrication rate. Always verify the model's claims about APIs, library behavior, or language features.

3. Security Coding

A 43.3% success rate on security coding tests is below Claude and GPT benchmarks. Apply extra review for security-sensitive code.

4. Time-to-First-Token (TTFT)

The free tier averages 11.5 seconds for the first token, which impacts interactive use.

5. No Production SLA

This is a preview model. Do not build production systems that depend on the free endpoint's availability.

The Bottom Line

Qwen 3.6 Plus is the most capable free AI model available right now. For developers who want to test a frontier-class model with 1M context, strong tool-calling, and competitive coding benchmarks — without spending a dollar — there's no reason not to try it.

The caveats are real: fabrication rate, security gaps, lack of production SLA, and data collection terms. But for evaluation, prototyping, and cost-sensitive production workloads that can tolerate these tradeoffs, Qwen 3.6 Plus deserves serious consideration.

Originally published at serenitiesai.com

Bring Your Own AI: How to Cut App Building Costs by 80% in 2026

Serenities AI — Thu, 26 Mar 2026 13:03:38 +0000

Here's a pricing math problem every startup founder should solve:

If you're paying $20/month for an AI tool that charges you again through markup on every API call, and that tool uses OpenAI's API which costs $0.01/1K tokens... how much of your money is actually going to AI?

The answer? Sometimes as little as 20%. The rest is margin for the middleman.

This is why the smartest builders in 2026 are switching to BYOK AI tools—Bring Your Own Key platforms that let you plug in your own API keys, eliminate markups, and cut AI costs by up to 80%.

What Are BYOK AI Tools?

BYOK (Bring Your Own Key) AI tools are applications and platforms that let you use your own API keys from AI providers like OpenAI, Anthropic, Google, or Mistral. Instead of the tool provider billing you at a markup for AI usage, you connect directly to the source.

The Traditional Model (Expensive)

You → AI SaaS Tool (adds 300-500% markup) → OpenAI

The BYOK Model (Smart)

You → BYOK Tool (minimal flat fee) → OpenAI (pay actual API cost)

Real Cost Comparison

AI Usage	Traditional Tool	BYOK Tool	Savings
100K tokens/month	$25-40/mo	~$3-5/mo	85%
1M tokens/month	$200-400/mo	~$30-50/mo	83%
10M tokens/month	$1,500-3,000/mo	~$200-300/mo	87%

Based on GPT-4o pricing of ~$2.50/1M input tokens + typical SaaS markup.

Why BYOK AI Tools Are Gaining Massive Traction

1. Cost Control

The primary driver is obvious: you pay API rates, not SaaS rates. When you use a traditional AI tool, you're paying:

The actual AI cost
Platform margin (often 300-500%)
Convenience premium
Infrastructure markup

With BYOK, you pay:

Actual AI cost
Small platform fee (if any)

2. Model Flexibility

BYOK tools don't lock you into a single AI provider. Today you might use GPT-4. Tomorrow, Anthropic's Claude Opus might be better for your use case. Next week, a new open-source model could outperform both.

With your own keys, you switch models without switching platforms.

3. Data Privacy & Security

When you use a traditional AI SaaS tool, your data flows through their servers before reaching the AI provider. That's two parties seeing your sensitive information.

With BYOK:

Your data goes directly to the AI provider
The tool sees structure, not content
You control data retention policies
Enterprise compliance becomes simpler

Best BYOK AI Tools by Category

All-Purpose AI Assistants

Tool	Platforms	Supported Providers	Key Feature
TypingMind	Web	OpenAI, Anthropic, Google, Mistral +	Best chat management & prompt libraries
MindMac	macOS	OpenAI, Azure, Google +	Native Mac performance
Msty	All	HuggingFace, Ollama, OpenRouter +	Works offline with local models
Witsy	All	15+ providers including local	Open-source MCP client

Developer & Coding

Tool	Best For	Supported Providers
CodeGPT	IDE integration	OpenAI, Anthropic, Gemini +
Refact.ai	Self-hosted code assist	OpenAI, HuggingFace
16x Prompt	Prompt engineering	Claude, DeepSeek

How to Calculate Your BYOK Savings

Step 1: Audit Current AI Spending

Track all AI-related costs:

Direct subscriptions (ChatGPT Plus, Claude Pro, etc.)
SaaS tools with AI features
API usage (if already using BYOK partially)

Step 2: Estimate Token Usage

Most tools don't show token counts. Use these estimates:

Task	Approximate Tokens
Short response (~100 words)	400-600 tokens
Blog post (~1,000 words)	4,000-6,000 tokens
Code review (~500 lines)	8,000-15,000 tokens
Document analysis (10 pages)	15,000-25,000 tokens

Step 3: Compare API Costs

Current API pricing (as of 2026):

Model	Input (per 1M tokens)	Output (per 1M tokens)
GPT-4o	$2.50	$10.00
GPT-4o-mini	$0.15	$0.60
Claude 3.5 Sonnet	$3.00	$15.00
Claude 3.5 Haiku	$0.25	$1.25
Gemini 1.5 Flash	$0.075	$0.30

The 10-25x Advantage: AI Subscriptions vs. API Pricing

Here's a secret most AI tools don't want you to know: the gap between consumer AI subscriptions and API pricing is enormous.

Service	Subscription	Equivalent API Cost	Multiplier
ChatGPT Plus	$20/mo	~$0.80-2.00 typical usage	10-25x
Claude Pro	$20/mo	~$1.50-3.00 typical usage	7-13x
Gemini Advanced	$20/mo	~$0.50-1.00 typical usage	20-40x

Subscriptions make sense if:

You need specific features (like Advanced Data Analysis)
You value simplicity over savings
You're a light user who doesn't maximize the subscription

API/BYOK makes sense if:

You're cost-conscious
You use AI heavily
You need model flexibility
You're building products

Getting Started with BYOK: Action Plan

This Week

Audit your current AI tool spending
Create accounts with major AI providers (OpenAI, Anthropic)
Set spending limits on each account (most providers support this)
Choose one BYOK tool to test

This Month

Migrate one workflow to BYOK
Track actual costs vs. previous spending
Expand successful migrations
Document prompts and workflows (they're portable now)

This Quarter

Evaluate total savings
Standardize on optimal tool stack
Train team on BYOK best practices
Build custom workflows using API access

Conclusion: The BYOK Future

The AI tool landscape in 2026 is bifurcating:

Premium SaaS: Convenience, support, and hand-holding at 5-10x markup
BYOK Tools: Control, flexibility, and cost efficiency for savvy users

Neither is universally better. But if you're building AI-powered products, automating at scale, or simply want control over your AI costs, BYOK isn't optional—it's essential.

The question isn't whether you should explore BYOK AI tools. It's how quickly you can implement them before your competitors do.

Ready to cut your AI costs by 80%? Start with Serenities AI's BYOK-native platform and keep more money in your runway.

The Complete Guide to Vibe Coding in 2026: Everything You Need to Know

Serenities AI — Tue, 24 Mar 2026 12:42:23 +0000

Vibe coding went from a throwaway tweet to a movement that's reshaping how software gets built. In 2026, everyone from solo founders to Fortune 500 engineering teams is using AI to write code — and the results are no longer just weekend projects. They're production applications generating real revenue.

This is the definitive guide to vibe coding in 2026. Whether you're a non-technical founder who wants to build your first app, a developer looking to 10x your output, or a team lead evaluating AI coding tools for your organization — this guide covers everything: what vibe coding actually is, the best tools available today, how to do it safely, what it really costs, and where it's heading next.

What Is Vibe Coding? The Origin Story

The term "vibe coding" was coined by Andrej Karpathy — co-founder of OpenAI and former AI leader at Tesla — in February 2025. In a now-famous post, he described a new way of programming where you "fully give in to the vibes, embrace exponentials, and forget that the code even exists."

The idea was simple but radical: instead of writing code line by line, you describe what you want in plain English, and an AI generates the code for you. You test it, give feedback, and iterate — never needing to read or understand the actual code that's produced.

[Continue reading the complete guide...]

This is a cross-post. Read the full article with all examples, comparisons, and updates at: https://serenitiesai.com/articles/complete-guide-vibe-coding-2026

Top 6 Coding Plans for Vibe Coding in 2026: Every Price Verified

Serenities AI — Mon, 16 Mar 2026 13:05:40 +0000

The Real Cost of Vibe Coding in 2026

Vibe coding burns through tokens fast. One debugging session with extended thinking can eat half your daily quota before lunch. And if you're still paying per API call, a single afternoon of iterating on a complex feature can cost more than a monthly subscription.

That's why subscription-based coding plans have exploded in 2026. Instead of watching your API bill climb with every prompt, you pay a flat monthly fee and code until you hit a rolling limit — then wait a few hours and start again.

We tested and compared every major coding plan available in March 2026. Here's what you actually get for your money.

Quick Comparison: All 6 Coding Plans

Provider	Monthly Price	Usage Limit	Reset Style	Best For
Claude Code	$17–$200	~10–800 prompts/5hr	Rolling 5hr + weekly caps	Long iterative sessions
ChatGPT Codex	$8–$229	Varies by plan	Rolling windows	General coding + GPT-5 ecosystem
Google AI	$7.99–$249.99	Daily quotas	Daily reset	Steady daily coding
GLM (Z.ai)	$9–$72	~80–1,600 prompts/5hr	Rolling 5hr + weekly caps	Budget vibe coding
MiniMax	$10–$150	100–2,000 prompts/5hr	Rolling 5hr	Sprint-based coding
Cerebras Code	$50–$200	24M–120M tokens/day	Daily reset	High-speed continuous coding

This article was originally published at serenitiesai.com with full detailed analysis of all 6 plans, pricing tables, and selection framework.

Is Vibe Coding Replacing Developers in 2026? What the Community Actually Says

Serenities AI — Mon, 16 Mar 2026 00:09:13 +0000

Originally published at serenitiesai.com

Vibe coding is everywhere in 2026. From Samsung's unexpected pivot to Replit's explosive growth, AI-powered app building has moved from Silicon Valley experiments to mainstream enterprise adoption.

But the question everyone's asking isn't if vibe coding will change software development — it's how much and how fast.

After analyzing developer surveys, enterprise adoption rates, and community discussions across Reddit, Twitter, and Hacker News, here's what the data actually shows about vibe coding's impact on the developer job market in 2026.

The Numbers That Matter

The stats on vibe coding adoption tell a clear story:

Enterprise adoption up 340% in Q4 2025 (McKinsey Digital)
Samsung pivoted their entire app strategy to vibe coding in late 2025
Replit's revenue grew 10x after launching Agent mode
43% of Fortune 500 companies now use vibe coding for internal tools

But what does this mean for developers?

What Developers Are Actually Saying

The developer community is split, but not in the way you'd expect. Here are the real perspectives from those working with these tools daily:

The Optimists (45%)
"Vibe coding handles the boring stuff so I can focus on architecture and complex problems." - Senior Dev at fintech startup

The Pragmatists (40%)
"It's just another tool. Good for rapid prototyping, but you still need real developers for production systems." - Lead Engineer at SaaS company

The Skeptics (15%)
"AI can't understand business requirements or handle edge cases. This is overhyped." - Full-stack developer

Continue reading the full analysis at serenitiesai.com →

This article dives deep into:

Enterprise adoption patterns and real ROI data
Which types of developer roles are most affected
Community reactions from Reddit, HN, and Twitter
Predictions from industry leaders
How platforms like Serenities AI are democratizing app development

Read the complete analysis: Is Vibe Coding Replacing Developers in 2026? What the Community Actually Says

AI Agent Memory: Why 2026 is the Year of Persistent Context

Serenities AI — Sat, 14 Mar 2026 13:04:04 +0000

Originally published at serenitiesai.com

Every AI agent has the same problem: amnesia.

You've experienced it. You spent an hour explaining your project requirements to an AI assistant, crafted the perfect workflow, then returned the next day to find... nothing. A blank slate. All that context, gone.

This isn't a minor inconvenience. It's the fundamental bottleneck holding AI agents back from becoming truly useful.

But 2026 is changing everything.

Why AI Agent Memory Matters More Than Ever

When large language models first entered the enterprise, the promise seemed simple: just fill the context window with everything the agent might need. More tokens, better results, right?

That illusion collapsed under real workloads.

Performance degraded. Retrieval became expensive. Costs compounded. Researchers started calling it "context rot"—where simply enlarging context windows actually made responses less accurate, not more.

The problem runs deeper than token limits. Traditional LLMs are fundamentally stateless. Every interaction starts fresh. There's no memory of past decisions, no understanding of evolving preferences, no accumulated wisdom from previous sessions.

For short conversations, this works fine. For workflows that span days, weeks, or entire projects? It's crippling.

Consider what you're missing:

A sales copilot that remembers previous customer conversations could cut research time in half
A customer service agent with durable recall could dramatically reduce churn
A coding assistant that tracks your architectural decisions could eliminate repetitive explanations
An enterprise knowledge system that learns from every interaction could preserve institutional wisdom

The stakes are enormous. And in 2026, the technology finally exists to solve this problem.

The Memory Revolution: Three Approaches Battling for Dominance

Human memory evolved as a layered system precisely because holding everything in working memory is impossible. We compress, abstract, and forget to function. AI systems need the same architectural sophistication.

Today, three distinct philosophies dominate the AI agent memory landscape:

1. Vector Store Approach: Memory as Retrieval

Systems like Pinecone and Weaviate store past interactions as embeddings in a vector database. When queried, the agent retrieves the most relevant fragments by similarity matching.

Strengths:

Fast and conceptually simple
Scales to massive datasets
Well-established infrastructure

Weaknesses:

Prone to surface-level recall
Loses relationships between facts
Can't track how information changes over time

This approach finds similar text but treats each memory independently. Your agent might know you like coffee, but it won't understand that you prefer coffee from a specific shop, ordered last Tuesday, while discussing your morning routine.

2. Summarization Approach: Memory as Compression

Rather than storing everything, these systems periodically condense transcripts into rolling summaries. Think of it as creating CliffsNotes of your conversation history.

Strengths:

Dramatically reduces token usage
Preserves key insights
Works well for linear narratives

Weaknesses:

Loses granular details
Summarization quality varies
Can introduce compression artifacts

3. Graph Approach: Memory as Knowledge

The most ambitious systems organize memories as interconnected nodes and relationships—people, places, events, and time. The graph stores "who said what about whom and when."

Strengths:

Preserves rich relationships
Enables multi-hop reasoning
Tracks temporal evolution

Weaknesses:

More complex to implement
Requires careful schema design
Can become computationally expensive at scale

The Leading Memory Solutions of 2026

The startup ecosystem has exploded with solutions tackling AI agent memory from different angles. Here are the leading platforms:

Mem0: Hybrid Memory with Enterprise Focus

Mem0 combines vector-based semantic search with optional graph memory for entity relationships. The system maintains cross-session context through hierarchical memory at user, session, and agent levels.

Key results:

26% accuracy gain on standard memory benchmarks
Significant token cost reduction
Automatic memory extraction without manual orchestration

The platform supports both open-source self-hosting and managed cloud service with SOC 2 compliance, making it enterprise-ready.

Zep: Temporal Knowledge Graphs

Zep's approach focuses on tracking how facts change over time. Instead of treating memories as static, it integrates structured business data with conversational history.

Performance highlights:

18.5% improvement in long-horizon accuracy over baseline retrieval
Nearly 90% latency reduction
Multi-hop and temporal query support

This makes Zep particularly powerful for enterprise scenarios requiring relationship modeling and temporal reasoning.

Claude-Mem: Persistent Memory for Coding Agents

For developers using Claude Code, Claude-mem solves the session amnesia problem by automatically capturing tool usage observations, generating semantic summaries, and making relevant context available to future sessions.

The approach:

Capture: Records user prompts, tool usage, and observations during sessions
Compress: Creates compact, indexed memory units using AI
Retrieve: Intelligently injects relevant context when new sessions start

This reduces token usage by up to 95% while maintaining project continuity across coding sessions.

The Architecture of Intelligent Memory

Effective AI agent memory isn't just about storing information. It requires three distinct capabilities working together:

Agents generate enormous amounts of text, much of it redundant. Good memory requires salience detection—identifying which facts matter.

Different systems approach this differently:

Mem0 uses a "memory candidate selector" to isolate atomic statements
Zep encodes entities and relationships explicitly
Memvid relies on frame-based indexing with timestamps

Consolidation: How Do Memories Evolve?

Human recall is recursive—we re-encode memories each time we retrieve them, strengthening some and discarding others. AI systems can mimic this by summarizing or rewriting old entries when new evidence appears.

This prevents "context drift" where outdated facts persist and contaminate current reasoning.

Retrieval: How Do We Find What We Need?

The best systems weight relevance by both recency and importance. They understand that:

Recent information often supersedes older data
Some facts are always relevant regardless of age
Context determines which memories matter

Done right, these layers produce agents that evolve alongside users. Done poorly, they create brittle systems that hallucinate old facts, repeat mistakes, or lose trust altogether.

What 2026 Holds: Three Trajectories

Based on current developments, expect these trends to accelerate:

Memory as Infrastructure

Developers will call memory.write() as easily as they now call db.save(). Specialized providers will evolve into middleware for every agent platform. Memory APIs will become as standardized as database APIs.

Memory as Governance

Enterprises will demand visibility into what agents know and why. Dashboards will show "memory graphs" of learned facts with controls to edit or erase. Transparency will become table stakes; memories will be written in natural language that humans can audit.

Memory as Identity

Over time, agents will develop personal histories—records of collaboration, preferences, even patterns. That history will anchor trust but raise new philosophical questions. When a model fine-tuned on your interactions generates insight, whose memory is it?

Getting Started: Your Next Steps

The AI agent memory revolution isn't coming—it's here. If you're building agents today, here's how to move forward:

For simple use cases: Start with summarization-based approaches. They're easy to implement and work well for straightforward assistants.

For enterprise applications: Evaluate Mem0 or Zep for their production-ready features and compliance capabilities.

For coding agents: Claude-mem or similar session-persistence tools can dramatically improve developer experience.

For maximum control: LangMem or Letta's tool-based approaches let you define exactly how memory works.

The winners in AI will be those who solve the memory problem—not with bigger context windows, but with intelligent systems that remember what matters, forget what doesn't, and learn from every interaction.

2026 is the year persistent context goes from experimental to essential. The only question is: will your agents remember, or will they forget?

Building AI agents that need to remember? Read the full article at serenitiesai.com for more details on implementation and architecture.

GPT-5.4 Is Here: Everything Developers and Builders Need to Know

Serenities AI — Fri, 13 Mar 2026 13:03:07 +0000

OpenAI just dropped GPT-5.4 — and it's not just another incremental update. Released on March 5, 2026, this model combines frontier coding capabilities, native computer-use, and a 1M token context window into a single package designed for professional work. If you build apps, automate workflows, or run AI-powered businesses, here's exactly what changed and why it matters.

TL;DR — What's New in GPT-5.4

Feature	GPT-5.4	GPT-5.2 (Previous)
Computer Use	Native — operate desktops, browsers, apps	Not available
Context Window	Up to 1M tokens	128K–256K
Tool Search	47% fewer tokens for tool-heavy workflows	All tools loaded upfront
Knowledge Work (GDPval)	83.0% (matches/exceeds professionals)	70.9%
OSWorld (Desktop Use)	75.0% — surpasses human performance (72.4%)	47.3%
Coding (SWE-Bench Pro)	57.7%	55.6%
API Pricing (Input)	$2.50/M tokens	$1.75/M tokens
API Pricing (Output)	$15/M tokens	$14/M tokens

1. Native Computer Use — The Headline Feature

GPT-5.4 is OpenAI's first general-purpose model with native computer-use capabilities. This isn't a bolted-on feature — it's built into the model itself.

What does that mean practically? GPT-5.4 can:

Navigate desktop environments through screenshots and keyboard/mouse actions
Write Playwright code to automate browser workflows
Issue mouse and keyboard commands in response to what it sees on screen
Complete multi-step workflows across different applications

The benchmark results tell the story. On OSWorld-Verified, which measures a model's ability to navigate desktop environments, GPT-5.4 hits 75.0% — exceeding human performance at 72.4% and obliterating GPT-5.2's 47.3%. That's a 59% relative improvement in one generation.

2. Tool Search — Finally, Efficient Tool Ecosystems

GPT-5.4 introduces tool search. Instead of loading all tool definitions into context, the model receives a lightweight list and looks up specific tool definitions only when needed.

Testing with 250 tasks from Scale's MCP Atlas benchmark with all 36 MCP servers enabled, tool search reduced total token usage by 47% while achieving the same accuracy.

3. 1M Token Context Window

GPT-5.4 supports up to 1M tokens of context — 4x Claude's current 256K limit. There's a catch: requests exceeding 272K context count against usage limits at 2x the normal rate.

Long-context performance:

4K–128K: 86–97% accuracy (strong)
128K–256K: 79.3% (good)
256K–512K: 57.5% (moderate drop-off)
512K–1M: 36.6% (significant degradation)

4. Professional Knowledge Work — 83% Match With Experts

On GDPval, GPT-5.4 matches or exceeds professionals in 83.0% of comparisons across 44 occupations — up from 70.9% for GPT-5.2.

Specific improvements:

Spreadsheet modeling: 87.3% mean score on investment banking analyst tasks
Factual accuracy: 33% fewer false individual claims

API Pricing Breakdown

Model	Input Price	Output Price
gpt-5.2	$1.75/M tokens	$14/M tokens
gpt-5.4	$2.50/M tokens	$15/M tokens
gpt-5.4-pro	$30/M tokens	$180/M tokens

GPT-5.4 costs ~43% more per input token than GPT-5.2, but OpenAI claims greater token efficiency reduces total tokens required for many tasks.

Competitor comparison:

GPT-5.4: $2.50/M input, $15/M output
Claude Opus 4.6: $5/M input, $25/M output
Claude Sonnet 4.6: $3/M input, $15/M output

Cost savings tip: With platforms like Serenities AI, you can connect your existing ChatGPT subscription instead of paying per-token API costs — potentially saving 10-25x on AI costs at scale.

What This Means for Builders

Computer use changes the agent game — Models can directly operate software, unlocking automation scenarios previously impossible
Tool search makes MCP practical at scale — No more token bloat from dozens of MCP servers
Professional work capabilities are real — 83% match rate with professionals isn't a toy demo
Cost efficiency matters more than raw price — Fewer tokens per task may offset higher per-token costs

FAQ

When was GPT-5.4 released?

March 5, 2026, with gradual rollout across ChatGPT, Codex, and API.

How much does GPT-5.4 cost?

API: $2.50/M input, $15/M output. In ChatGPT, access depends on your subscription plan.

Can GPT-5.4 use my computer?

Yes — native computer-use capabilities via the API's computer tool.

How does it compare to Claude Opus 4.6?

GPT-5.4 is significantly cheaper and leads on computer use. Both are frontier-class for coding.

Bottom Line

GPT-5.4 isn't just better — it's a different kind of model. Native computer use, tool search, and 1M context transform what's possible for agents and professional automation.

The age of AI agents that actually do professional work isn't coming. It just shipped.

Originally published at serenitiesai.com

Claude Pro vs Max Plans 2026: Limits, Pricing & Which to Choose

Serenities AI — Mon, 09 Mar 2026 16:34:21 +0000

Here's an uncomfortable truth: most people paying for Claude are on the wrong plan. Some are overpaying $80/month for Max features they barely touch. Others are grinding through Pro usage caps when a Max subscription would save them hours of waiting every week. Anthropic’s pricing page looks simple — $20/month, $100/month, or $200/month — but the real differences between Claude Pro and Max are buried in usage multipliers, feature access, and workflow-specific perks that most comparison articles completely ignore. This guide breaks down exactly what you get at each tier so you can stop guessing and start choosing.

TL;DR: Claude Pro vs Max at a Glance

Feature	Claude Pro ($20/mo)	Claude Max (from $100/mo)
Monthly Price	$20/mo or $17/mo annual	From $100/mo
Usage vs Pro	1x (baseline)	5x or 20x more
Claude Code	✅	✅ (higher limits)
Cowork	✅	✅
Research	✅	✅
Projects	✅ Unlimited	✅ Unlimited
Claude in Excel	✅	✅
Claude in PowerPoint	❌	✅ (preview)
Higher Output Limits	❌	✅
Priority Access	❌	✅
Context Window	200k tokens	200k tokens
Best For	Daily professionals	Power users, agencies

Claude Pro: What You Get for $20/Month

Claude Pro is Anthropic’s core paid tier. At $20/month (or $17/month annual at $200/yr), you unlock everything that makes Claude genuinely useful for professional work.

Usage: More Than Free, But Not Unlimited

Pro users get all models: Opus, Sonnet, and Haiku with 200k context windows. The jump from Free to Pro is substantial. But usage limits still apply — during peak hours, heavy Pro users may hit rate limits. This is the primary reason people consider Max.

Claude Code and Cowork

Claude Code is Anthropic’s terminal-based coding agent, included with every Pro subscription. It handles file edits, terminal commands, and multi-step coding tasks directly in your development environment.

Cowork is Claude’s collaborative mode — Claude works alongside you in real-time on longer projects, maintaining context and contributing proactively.

Research and Projects

Research conducts multi-step deep dives, synthesizes findings, and presents comprehensive results. Unlimited Projects let you organize work into persistent workspaces with custom instructions and knowledge bases.

Claude in Excel

Integrates Claude directly into Microsoft Excel spreadsheets — eliminates copy-paste workflows between Claude and your data.

Who Is Pro For?

Software developers using Claude Code daily
Writers and content creators
Analysts who need Research mode
Business professionals organizing work into Projects
Anyone hitting Free tier limits weekly

Claude Max: 5x and 20x Usage Explained

Max 5x ($100/Month)

5x more usage than Pro. Eliminates rate limits that plague Pro users during heavy work sessions. Higher output limits mean Claude can generate longer responses in a single turn.

Max 20x ($200/Month)

20x Pro usage for agencies, dev teams using Claude Code as a core pipeline tool, and researchers conducting marathon sessions daily.

Max-Exclusive Features

Claude in PowerPoint (Research Preview): Max-only, lets you use Claude inside PowerPoint presentations.

Priority Access: Max users get served first during peak hours.

Early Access: New capabilities roll out to Max users first.

What Max Does NOT Give You

Same 200k context window, same models, same response quality. Max is about quantity and access, not quality.

Feature Comparison: Free vs Pro vs Max

Feature	Free	Pro ($20/mo)	Max (from $100/mo)
All platforms	✅	✅	✅
Code Generation	✅	✅	✅
Web Search	✅	✅	✅
Extended Thinking	✅	✅	✅
MCP Connectors	✅	✅	✅
Claude Code	❌	✅	✅
Cowork	❌	✅	✅
Research	❌	✅	✅
Projects	❌	✅	✅
Excel	❌	✅	✅
PowerPoint	❌	❌	✅ (preview)
5x/20x Usage	❌	❌	✅
Priority Access	❌	❌	✅

Pricing Breakdown

Plan	Monthly	Annual	Per Usage Unit
Pro	$20/mo	$200/yr ($17/mo)	$20
Max 5x	~$100/mo	N/A	~$20
Max 20x	$200/mo	N/A	$10

You’re not getting a volume discount with Max 5x — you’re paying proportionally for proportionally more usage. The value is removing the ceiling.

The Hidden Cost: Lost Productivity

A developer billing $100+/hour who loses 30 minutes/day to rate limits = $1,000/month in lost productivity. Max at $100/month saves $900/month.

Real-World Scenarios

Casual user (few times/week): Free tier is plenty.

Daily professional (3-4 hrs/day): Pro handles it. Go annual at $200/yr.

Heavy coder (8+ hrs/day): Max 5x eliminates daily rate limit frustration.

Agency lead (50+ conversations/day): Max 20x pays for itself many times over.

Claude Code: The Upgrade Driver

Your Usage	Plan	Why
Don’t use it	Free/Pro	No need for Max
< 1 hr/day	Pro	Limits sufficient
1-3 hrs/day	Pro (watch limits)	May hit limits on heavy days
4+ hrs/day	Max 5x	Pro limits frustrate daily
All-day pairing	Max 20x	Even 5x may not suffice

Is Max Worth It?

Yes if: You hit Pro limits regularly, use Claude 4+ hrs/day, bill $75+/hour, or need priority access.

No if: You rarely hit limits, use Claude occasionally, want better quality (it’s identical), or mainly want PowerPoint.

Verdict: Start with Pro. Upgrade to Max only after 2-3 months of consistently hitting limits.

FAQ

What are Claude Pro’s exact limits? Anthropic doesn’t publish specific counts. Limits are dynamic based on model, conversation length, and server load.

Does Pro have a fallback model? When approaching limits, Anthropic may route you to lighter models (Sonnet/Haiku instead of Opus).

Can I switch mid-month? Yes, upgrades are prorated. Downgrades take effect at billing cycle end.

Is there a team plan? Yes — Claude Team and Enterprise plans exist with admin controls and shared billing.

Originally published on Serenities AI

How to Set Up MCP Servers in Cursor IDE: Complete Guide 2026

Serenities AI — Mon, 09 Mar 2026 13:07:34 +0000

You've heard the buzz about MCP servers in Cursor, but every time you try to set one up, you hit a wall. Maybe the config file isn't being read. Maybe the server starts but Cursor can't see the tools. Or maybe you're just not sure where to begin — stdio, SSE, HTTP… what does any of it mean?

You're not alone. The Model Context Protocol (MCP) is one of the most powerful features in Cursor IDE, letting your AI assistant connect to external tools, databases, APIs, and data sources. But the documentation can feel scattered, and getting your first mcp server cursor setup working requires understanding a few key concepts.

This guide fixes that. By the end, you'll have MCP servers running in Cursor — whether you're a Node.js developer, a Python programmer, or someone deploying remote servers for a team. No guesswork, no frustration, just working configurations.

What You'll Learn

This comprehensive guide covers everything you need to set up and use MCP servers in Cursor IDE:

What MCP is and why it matters for AI-assisted development
Three transport methods — stdio, SSE, and Streamable HTTP — and when to use each
Step-by-step setup for local stdio servers (Node.js and Python examples)
Remote server configuration for HTTP and SSE endpoints
Configuration locations — project-level vs. global config files
Config interpolation — using environment variables and workspace paths
OAuth and authentication for secure server connections
Using MCP tools in Cursor's chat and agent modes
Security best practices to keep your setup safe
Troubleshooting tips for common issues

Let's dive in.

Prerequisites

Before you start configuring MCP servers in Cursor, make sure you have these basics in place:

Requirement	Details
Cursor IDE	Installed and running. MCP support is available on all Cursor plans (Free, Pro, Ultra, and Enterprise).
Node.js (for JS servers)	Version 18+ recommended. Needed for npx-based MCP servers.
Python (for Python servers)	Version 3.10+ recommended. Needed for Python-based MCP servers.
A terminal	You'll need basic command-line comfort for testing servers.
A text editor	For editing JSON config files (Cursor itself works great for this).

If you're only setting up remote MCP servers (HTTP/SSE), you don't need Node.js or Python installed locally — just the server URL.

What Is MCP? (Model Context Protocol Explained)

The Model Context Protocol (MCP) is an open standard that enables AI coding assistants like Cursor to connect to external tools and data sources. Think of it as a universal adapter between your AI and the outside world.

Without MCP, your AI assistant is limited to what it can see in your codebase and its training data. With MCP, it can:

Query databases directly to understand your schema and data
Call APIs — search the web, check deployment status, create tickets
Access documentation from external sources in real time
Interact with services like GitHub, Jira, Slack, or your own custom tools
Read and write files beyond your workspace boundaries

MCP works by defining a standard JSON-RPC protocol between the AI client (Cursor) and external servers. You can write MCP servers in any language that can print to stdout or serve an HTTP endpoint — Python, JavaScript, Go, Rust, and more.

The Five Protocol Capabilities

MCP in Cursor supports five protocol capabilities, all of which are fully supported:

Capability	What It Does	Cursor Support
Tools	Functions for the AI model to execute (e.g., search a database, call an API)	✅
Prompts	Templated messages and workflows the server can expose	✅
Resources	Structured data sources the AI can query	✅
Roots	Server-initiated inquiries into URI or filesystem boundaries	✅
Elicitation	Server-initiated requests for additional information from the user	✅

This full protocol support means Cursor's MCP implementation is among the most complete available.

How MCP Works in Cursor: Transport Methods

When setting up an MCP server in Cursor, the first decision you need to make is which transport method to use. Cursor supports three transport types:

Transport	Execution	Deployment	Users	Input	Auth
stdio	Local	Cursor manages	Single user	Shell command	Manual
SSE	Local/Remote	Deploy as server	Multiple users	URL to SSE endpoint	OAuth
Streamable HTTP	Local/Remote	Deploy as server	Multiple users	URL to HTTP endpoint	OAuth

When to Use Each Transport

stdio (Standard I/O) is the most common choice for individual developers. Cursor launches the server process itself and communicates through stdin/stdout. Use stdio when:

You're a solo developer working on your own machine
The MCP server needs access to local files or tools
You want zero deployment overhead
You're using community MCP packages via npx or pip

SSE (Server-Sent Events) is ideal for remote or shared servers. Use SSE when:

Multiple team members need the same MCP server
The server needs to run persistently
You're connecting to a hosted MCP service
You need OAuth-based authentication

Streamable HTTP is the newest transport method. Use it when:

You're building a new remote MCP server from scratch
You want better compatibility with standard HTTP infrastructure
You need OAuth authentication
Your infrastructure doesn't support SSE well

Step-by-Step: Setting Up stdio MCP Servers

The stdio transport is the fastest way to get an MCP server running in Cursor.

Understanding the Config File

For stdio servers, you'll need these fields:

Field	Required	Description
type	Yes	Server connection type — set to "stdio"
command	Yes	Command to start the server (e.g., npx, node, python, docker)
args	No	Array of arguments passed to the command
env	No	Environment variables for the server process
envFile	No	Path to a .env file (stdio only)

Example 1: Node.js MCP Server via npx

Step 1: Create the config file. In your project root:

mkdir -p .cursor
touch .cursor/mcp.json

Step 2: Add your server configuration:

{
  "mcpServers": {
    "server-name": {
      "command": "npx",
      "args": ["-y", "mcp-server"],
      "env": {
        "API_KEY": "your-api-key-here"
      }
    }
  }
}

Step 3: Restart Cursor (or reload the window).

Step 4: Verify it's working. Open the Cursor chat (Agent mode) and look for the server's tools listed under "Available Tools."

Example 2: Python MCP Server

{
  "mcpServers": {
    "my-python-server": {
      "command": "${workspaceFolder}/.venv/bin/python",
      "args": ["${workspaceFolder}/mcp-server.py"],
      "env": {
        "API_KEY": "your-api-key-here"
      }
    }
  }
}

Running Multiple stdio Servers

You can configure as many MCP servers as you need:

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "ghp_your_token_here"
      }
    },
    "database": {
      "command": "python",
      "args": ["db-mcp-server.py"],
      "env": {
        "DATABASE_URL": "postgresql://localhost:5432/mydb"
      }
    },
    "search": {
      "command": "npx",
      "args": ["-y", "mcp-server-brave-search"],
      "env": {
        "BRAVE_API_KEY": "your-brave-key"
      }
    }
  }
}

Step-by-Step: Setting Up Remote MCP Servers (HTTP/SSE)

Remote MCP servers are perfect for team environments or hosted services.

Remote Server Configuration

{
  "mcpServers": {
    "server-name": {
      "url": "http://localhost:3000/mcp",
      "headers": {
        "API_KEY": "your-api-key-here"
      }
    }
  }
}

Connecting to a Cloud-Hosted MCP Server

{
  "mcpServers": {
    "team-tools": {
      "url": "https://mcp.yourcompany.com/tools",
      "headers": {
        "Authorization": "Bearer your-team-token"
      }
    }
  }
}

SSE vs. Streamable HTTP

SSE — Well-established protocol, works great for most deployments
Streamable HTTP — Newer standard, better for serverless and modern HTTP infrastructure

If building from scratch, Streamable HTTP is recommended.

Configuration Locations: Project vs. Global

Config Location	Path	Scope	Best For
Project config	.cursor/mcp.json	Current project only	Project-specific tools, shared team config
Global config	~/.cursor/mcp.json	All projects	Personal tools you want everywhere

When both configs define a server with the same name, the project config takes precedence.

Config Interpolation: Environment Variables and Workspace Paths

Available Interpolation Variables

Variable	Resolves To	Example
${env:NAME}	Environment variable value	${env:GITHUB_TOKEN}
${userHome}	Path to home folder	${userHome}/.config/keys.json
${workspaceFolder}	Project root directory	${workspaceFolder}/scripts/server.py
${workspaceFolderBasename}	Project root folder name	Used for dynamic naming
${pathSeparator} or ${/}	OS path separator	/ on Mac/Linux, \ on Windows

Secure API Key Management

{
  "mcpServers": {
    "github": {
      "command": "npx",
      "args": ["-y", "@modelcontextprotocol/server-github"],
      "env": {
        "GITHUB_TOKEN": "${env:GITHUB_TOKEN}"
      }
    }
  }
}

Then set in your shell profile:

export GITHUB_TOKEN="ghp_your_actual_token_here"

Using envFile for Local Development

{
  "mcpServers": {
    "my-server": {
      "command": "node",
      "args": ["server.js"],
      "envFile": "${workspaceFolder}/.env"
    }
  }
}

OAuth and Authentication

For remote MCP servers requiring secure authentication, Cursor supports OAuth flows.

The OAuth callback URL for Cursor is:

cursor://anysphere.cursor-mcp/oauth/callback

Many MCP servers now support one-click installation from the MCP directory, automatically configuring OAuth.

Using MCP Tools in Cursor Chat

Once configured, MCP tools appear under "Available Tools" in the chat interface. The agent automatically uses them when relevant.

Key features:

Plan Mode support — MCP tools work in Plan Mode too
Toggle tools on/off — Reduce noise by disabling unused tools
Tool approval — Default safety feature requiring confirmation before tool execution
Auto-run option — Skip approval for trusted servers (use cautiously)
Image responses — MCP servers can return base64-encoded images rendered in chat

Security Best Practices

Verify the source — Only install MCP servers from trusted developers
Review permissions — Understand what data and APIs each server can access
Limit API keys — Create dedicated keys with minimal permissions
Audit code — Review source code for critical integrations
Use environment variables — Never hardcode secrets in mcp.json
Keep tool approval enabled — The extra confirmation prevents costly mistakes

Common Troubleshooting Tips

Server Doesn't Appear in Available Tools

Verify config file is at .cursor/mcp.json (not .vscode/mcp.json)
Check for invalid JSON syntax
Restart Cursor or reload the window

Server Starts But Tools Don't Work

Check dependencies are installed (Node.js, Python packages)
Verify command path (use full path for virtual environments)
Run the command manually in terminal to see errors

Environment Variables Not Resolving

Ensure variables are set in the right shell context
Use ${env:VARIABLE_NAME} syntax (not $VARIABLE_NAME)

Remote Server Connection Fails

Verify server is online
Check firewall/network connectivity
Double-check authentication headers
Check for CORS issues

OAuth Flow Fails

Verify redirect URI is cursor://anysphere.cursor-mcp/oauth/callback
Try disconnecting and reconnecting
Check scope configuration

How Serenities AI Integrates with MCP

If you're using Serenities AI as your AI development platform, it supports MCP natively. The same MCP servers you configure in Cursor work with Serenities AI's workflows.

Serenities AI also offers built-in MCP server support — you can expose your Serenities AI workspace as an MCP server that Cursor connects to, creating a powerful two-way bridge between your AI tools.

Frequently Asked Questions

Is MCP available on Cursor's free plan?

Yes. MCP support is available across all Cursor plans, including the free tier.

Can I use MCP servers written in languages other than Node.js and Python?

Absolutely. Any language that can handle JSON-RPC communication works — Go, Rust, Java, Ruby, C#, and more.

What's the difference between project-level and global MCP configuration?

Project-level config (.cursor/mcp.json) only applies to the current project. Global config (~/.cursor/mcp.json) applies to every project. Project config takes precedence if both define the same server name.

Is it safe to commit .cursor/mcp.json to version control?

Yes, as long as you use config interpolation (${env:API_KEY}) instead of hardcoding secrets.

Can MCP servers return images or other non-text data?

Yes. MCP servers can return base64-encoded images rendered directly in Cursor's chat interface.

Conclusion

Setting up MCP servers in Cursor transforms your AI coding assistant from a smart autocomplete tool into a connected, context-aware development partner. With MCP, Cursor can query your databases, check your CI/CD pipelines, search documentation, manage tickets, and interact with virtually any external service.

The MCP ecosystem is growing fast — learn the protocol once, and use it everywhere.

Originally published on Serenities AI

Windsurf vs GitHub Copilot: Which AI Coding Tool Wins? (2026)

Serenities AI — Sun, 08 Mar 2026 13:05:22 +0000

Here's the bottom line: Windsurf and GitHub Copilot represent two fundamentally different visions for AI-assisted development. One wants to be your editor. The other wants to live inside your editor. After comparing pricing, features, and real-world workflows, the right choice depends entirely on whether you want a purpose-built AI IDE or an AI layer on top of the tools you already use.

Quick Verdict: Windsurf vs Copilot at a Glance (TL;DR)

Category	Windsurf	GitHub Copilot
Type	Standalone AI IDE	AI extension for multiple IDEs
Starting Price	Free / $15/mo Pro	Free / $10/mo Pro
Key Differentiator	Cascade agentic flow + SWE-1.5 model	Agent mode + GitHub PR/issue integration
IDE Support	Windsurf IDE only (VS Code-based)	VS Code, Visual Studio, JetBrains, Eclipse, Xcode, CLI
Best For	Developers wanting a deeply integrated AI IDE experience	Teams using GitHub who want AI across any IDE
MCP Support	Yes	Yes (all plans)

Quick take: Choose Windsurf if you want an all-in-one AI coding environment with deep agentic capabilities built into the editor itself. Choose GitHub Copilot if you're already embedded in the GitHub ecosystem, use JetBrains or other non-VS Code editors, or want the cheapest paid entry point at $10/month.

What Is Windsurf?

Windsurf positions itself as "tomorrow's editor, today" — a standalone AI-native IDE built on a VS Code foundation. Unlike extensions that bolt AI onto an existing editor, Windsurf was designed from the ground up to make AI a first-class citizen of the development experience.

Cascade: The Agentic Chatbot

Windsurf's flagship feature is Cascade, an agentic chatbot that goes well beyond simple code completion. Cascade operates as a collaborative coding partner that can understand your project context, suggest multi-file changes, and execute complex coding tasks through a conversational interface.

The "agentic" part is key: Cascade doesn't just respond to prompts — it can proactively identify issues, suggest refactors, and chain together multi-step operations. Think of it less like a chatbot and more like a junior developer who can read your entire codebase instantly.

SWE-1.5: Windsurf's Proprietary Model

One of Windsurf's unique advantages is SWE-1.5, their proprietary AI model specifically optimized for software engineering tasks. While Windsurf also provides access to all premium models, SWE-1.5 is purpose-built for coding workflows.

Getting Started with Windsurf

Because it's built on VS Code, you can import your existing configuration from VS Code or Cursor — extensions, keybindings, settings, and themes all carry over. Project-level configuration is handled through .windsurfrules files, which let you define AI behavior and coding standards.

The free tier includes unlimited Cascade usage (with limited prompt credits), meaning you can get a genuine feel for the agentic coding experience before committing to a paid plan.

What Is GitHub Copilot?

GitHub Copilot takes the opposite approach: rather than replacing your editor, it enhances it. Copilot is an AI coding assistant that works as an extension across VS Code, Visual Studio, JetBrains, Eclipse, Xcode, and even the CLI, GitHub.com, and GitHub Mobile.

Agent Mode and the Coding Agent

Copilot's agent mode brings agentic capabilities directly into your IDE of choice, powered by GPT-5 mini. Agent mode is available in VS Code, Visual Studio, JetBrains, Eclipse, and Xcode. On the Free plan, you get 50 agent mode requests per month, while Pro and Pro+ users get unlimited access.

The standout feature is Copilot's coding agent, which can be assigned GitHub issues and autonomously create pull requests to resolve them. Assign an issue, and Copilot will analyze the codebase, write the code, and open a PR for review. This is a game-changer for teams that live in GitHub.

Deep GitHub Ecosystem Integration

Where Copilot truly shines is integration with the broader GitHub platform:

Pull request reviews (Pro+) with AI-assisted code review feedback
File diff reviews directly in your workflow
Custom instructions via instructions.md files for team standardization
MCP server integration on all plans
Third-party agent delegation (Claude, OpenAI Codex) on Pro+

Free for Students and Open Source

GitHub Copilot is free for verified students, teachers, and open source maintainers — a significant perk that Windsurf doesn't match.

Feature-by-Feature Comparison

Feature	Windsurf	GitHub Copilot
Agentic AI	Cascade — deeply integrated	Agent mode (GPT-5 mini) across major IDEs
Code Completion	Yes, with Fast Context	Yes, inline suggestions
Chat Interface	Cascade conversational UI	Chat + agent mode
Proprietary Model	SWE-1.5 (software engineering optimized)	GPT-5 mini (agent mode)
Premium Models Access	All premium models included	Via premium requests (plan-dependent)
MCP Server Support	Yes	Yes (all plans)
PR/Issue Integration	No native integration	Coding agent creates PRs from issues
Code Review	Not a standalone feature	Pull request reviews + file diff reviews (Pro+)
Third-Party Agent Delegation	No	Claude, OpenAI Codex (Pro+)
Custom Instructions	.windsurfrules config files	instructions.md + custom agents
Deployment	Unlimited deploys (Pro+)	Not a built-in feature
Knowledge Base	Enterprise only	Via Copilot knowledge bases (Business/Enterprise)

Where Each Tool Wins

Windsurf wins on depth of AI integration. Because the entire IDE is built around AI, Cascade has deeper hooks into the editing experience than any extension can achieve. The SWE-1.5 model adds coding-specific optimization, and features like Fast Context ensure the AI understands your project with minimal setup. Windsurf also wins on deployment — unlimited deploys from Pro+ creates a streamlined code-to-production workflow.

GitHub Copilot wins on ecosystem breadth. The coding agent that creates PRs from issues is a fundamentally different workflow. Pull request reviews add another layer of value beyond the editor. Multi-IDE support is a decisive advantage — if your team uses JetBrains, Xcode, and VS Code, Copilot works for everyone.

Pricing Comparison (2026)

Windsurf Pricing

Plan	Price	Credits	Key Features
Free	$0/mo	Limited prompt credits	Unlimited Cascade, all premium models
Pro	$15/mo	500 credits/mo (+$10 for 250 add-on)	Unlimited deploys, Fast Context, SWE-1.5
Teams	$30/user/mo	500 credits/user/mo	Centralized billing, admin dashboard
Enterprise	Custom	1,000 credits/user/mo	Knowledge base, SSO, RBAC

GitHub Copilot Pricing

Plan	Price	Premium Requests	Key Features
Free	$0/mo	50/mo	Chat, agent mode (50/mo), MCP, custom instructions
Pro	$10/mo ($100/yr)	300/mo	Unlimited agent mode, all Free features
Pro+	$39/mo ($390/yr)	1,500/mo (+$0.04/extra)	PR reviews, third-party agents, app modernization

Pricing Analysis

At the paid entry point, Copilot wins on price: $10/month vs Windsurf's $15/month. Copilot Pro also offers annual billing at $100/year (effectively $8.33/month).

For power users, the comparison gets more nuanced. Windsurf Pro at $15/month gives 500 credits with $10 add-ons. Copilot Pro+ at $39/month provides 1,500 premium requests with overflow at $0.04 per request.

Copilot is free for verified students, teachers, and open source maintainers — if you qualify, the pricing comparison is moot.

IDE Support and Ecosystem

Windsurf: One IDE to Rule Them All

Windsurf is its own IDE built on VS Code. You can import existing VS Code or Cursor configuration. The trade-off: you must use the Windsurf editor. If your team uses JetBrains, Xcode, or Visual Studio, Windsurf isn't an option unless everyone switches.

The upside is a more tightly integrated AI experience — Cascade has deeper hooks into the editing environment than any extension could achieve.

GitHub Copilot: AI Everywhere You Code

Copilot supports:

VS Code — Full support including agent mode
Visual Studio — Full support including agent mode
JetBrains IDEs — Full support including agent mode
Eclipse — Full support including agent mode
Xcode — Full support including agent mode
GitHub CLI — AI-assisted command line
GitHub.com — AI in the browser
GitHub Mobile — AI on the go

A single Copilot subscription covers your entire development workflow — from writing code in JetBrains to reviewing PRs on GitHub.com to quick fixes on your phone.

Real-World Use Cases: When to Pick Each Tool

Pick Windsurf When...

You're a solo developer or small team building web applications — Cascade + SWE-1.5 + unlimited deploys creates a seamless code-to-production pipeline
You want the deepest AI integration — the AI experience is more cohesive than any extension
You're coming from VS Code or Cursor — import your existing config with zero setup cost
You value a coding-optimized model — SWE-1.5 is purpose-built for software engineering tasks

Pick GitHub Copilot When...

Your team lives in the GitHub ecosystem — coding agent creates PRs from issues, AI-assisted PR reviews
You use JetBrains, Xcode, Eclipse, or Visual Studio — Windsurf doesn't support these
You're a student, teacher, or open source maintainer — free Copilot access
You want multi-model flexibility — Pro+ delegates to Claude, OpenAI Codex, and GPT-5 mini
Budget is your primary concern — $10/month ($8.33/yr annual) is the cheapest paid option

Frequently Asked Questions

Is Windsurf better than GitHub Copilot for beginners?

It depends on your setup. Windsurf's free tier with unlimited Cascade is generous for learning. But if you're already in a specific IDE like JetBrains or Xcode, Copilot works where you already are. Copilot is also free for students and teachers.

Can I use Windsurf and GitHub Copilot together?

You can't run Copilot inside Windsurf since it's a standalone IDE. But you could use Windsurf for focused AI-driven sessions and keep Copilot in your JetBrains or Visual Studio environments for other projects.

Which tool has better code completion?

Both offer strong completion through different approaches. In practice, the quality difference for standard code completion is marginal — the real differentiation is in agentic capabilities and ecosystem integration.

Is Windsurf vs Copilot pricing worth it compared to Cursor?

For reference: Cursor Pro starts at $20/month, Windsurf Pro at $15/month, and Copilot Pro at $10/month. All three offer free tiers, so try each and see which workflow clicks.

Do both tools support MCP (Model Context Protocol)?

Yes. Both support MCP server integration for connecting external tools, databases, and APIs. Copilot includes MCP support on all plans, including the free tier.

Final Verdict

There is no universal winner. These tools serve different philosophies and different developers.

Choose Windsurf if you want a purpose-built AI IDE with the deepest agentic integration, are comfortable with a VS Code-based editor, and value built-in deployment and SWE-1.5.

Choose GitHub Copilot if you need multi-IDE support, live in the GitHub ecosystem, want AI-assisted PR reviews and a coding agent for issues, or want the cheapest paid option at $10/month.

Originally published at serenitiesai.com

Claude Code Hooks Guide 2026: Automate Your AI Coding Workflow

Serenities AI — Sat, 07 Mar 2026 14:31:26 +0000

What if Claude Code could automatically format your files after every edit, block dangerous shell commands before they execute, and run your test suite whenever code changes — all without you lifting a finger?

That's exactly what Claude Code hooks do. Hooks are lifecycle event listeners that let you attach custom logic to specific moments in Claude Code's execution pipeline. They intercept actions at precisely the right time — before a tool runs, after it succeeds, when a session starts, or when Claude finishes responding.

Think of hooks as middleware for your AI coding assistant. They give you programmatic control over Claude's behavior without modifying Claude itself.

This guide is the definitive resource on Claude Code hooks in 2026. We'll cover all 18 hook events, four hook types, configuration locations, and five production-ready recipes.

What You'll Learn

By the end of this guide, you'll understand the complete hook system. You'll know every lifecycle event, how to configure each hook type, and how data flows through the hook pipeline — from stdin JSON input to stdout decisions.

Prerequisites

Claude Code installed and working — Run claude from your terminal
jq installed — sudo apt install jq or brew install jq
Basic terminal/shell knowledge
A project directory — mkdir ~/hooks-playground && cd ~/hooks-playground

How Hooks Work: The stdin JSON Pattern

Command hooks receive event data as JSON on stdin. There is no $CLAUDE_TOOL_INPUT environment variable — that doesn't exist.

Here's what the JSON input looks like for a PreToolUse event:

{
  "hook_event_name": "PreToolUse",
  "tool_name": "Bash",
  "tool_input": {
    "command": "ls -la /home/user/project"
  },
  "session_id": "abc123...",
  "transcript_path": "/path/to/transcript",
  "cwd": "/home/user/project",
  "permission_mode": "default"
}

Reading it in bash:

#!/bin/bash
INPUT=$(cat)
TOOL_NAME=$(echo "$INPUT" | jq -r '.tool_name')
COMMAND=$(echo "$INPUT" | jq -r '.tool_input.command')

Output: Exit Codes and stdout JSON

Exit Code	Meaning	Behavior
0	Allow	Proceeds normally
2	Block	For PreToolUse: blocks the call
Other	Error	Hook failed

For granular control, output JSON to stdout:

jq -n '{
  hookSpecificOutput: {
    hookEventName: "PreToolUse",
    permissionDecision: "deny",
    permissionDecisionReason: "Destructive command blocked"
  }
}'

All 18 Hook Events

Event	When It Fires	Matchers?
SessionStart	Session begins/resumes/clears	Yes
InstructionsLoaded	CLAUDE.md or rules loaded	No
UserPromptSubmit	Before Claude processes prompt	No
PreToolUse	Before tool executes	Yes
PermissionRequest	Permission dialog appears	Yes
PostToolUse	After tool succeeds	Yes
PostToolUseFailure	After tool fails	Yes
Notification	Claude sends notification	Yes
SubagentStart	Subagent spawned	Yes
SubagentStop	Subagent terminates	Yes
Stop	Claude finishes responding	No
TeammateIdle	Teammate going idle	No
TaskCompleted	Task marked complete	No
ConfigChange	Config file changes	Yes
WorktreeCreate	Git worktree created	No
WorktreeRemove	Git worktree removed	No
PreCompact	Before compaction	Yes
SessionEnd	Session terminates	Yes

Hook Configuration Structure

Three-level JSON: event → matcher group → hook handler.

{
  "hooks": {
    "EVENT_NAME": [
      {
        "matcher": "REGEX_PATTERN",
        "hooks": [
          {
            "type": "command",
            "command": "your-script.sh"
          }
        ]
      }
    ]
  }
}

Four Hook Types

Type	Required	Optional	Timeout
command	type, command	timeout, async, statusMessage, once	600s
http	type, url	headers, allowedEnvVars, timeout	30s
prompt	type, prompt	model, timeout	—
agent	type, prompt	model, timeout	60s

Your First Hook: Blocking rm -rf /

{
  "hooks": {
    "PreToolUse": [
      {
        "matcher": "Bash",
        "hooks": [
          {
            "type": "command",
            "command": "COMMAND=$(cat | jq -r '.tool_input.command'); if echo \"$COMMAND\" | grep -qE 'rm\\s+-rf\\s+/'; then jq -n '{hookSpecificOutput: {hookEventName: \"PreToolUse\", permissionDecision: \"deny\", permissionDecisionReason: \"Blocked: rm -rf / detected\"}}'; else exit 0; fi"
          }
        ]
      }
    ]
  }
}

5 Production-Ready Recipes

Recipe 1: Auto-Format on File Save

#!/bin/bash
# .claude/hooks/auto-format.sh
INPUT=$(cat)
FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.path // empty')
if [ -z "$FILE" ] || [ ! -f "$FILE" ]; then exit 0; fi

EXT="${FILE##*.}"
case "$EXT" in
  js|jsx|ts|tsx|json|css|md) npx prettier --write "$FILE" 2>/dev/null ;;
  py) black --quiet "$FILE" 2>/dev/null ;;
  go) gofmt -w "$FILE" 2>/dev/null ;;
  rs) rustfmt "$FILE" 2>/dev/null ;;
esac
exit 0

Config:

{
  "hooks": {
    "PostToolUse": [{
      "matcher": "Edit|Write|MultiEdit",
      "hooks": [{
        "type": "command",
        "command": ".claude/hooks/auto-format.sh",
        "statusMessage": "Formatting..."
      }]
    }]
  }
}

Recipe 2: Block Dangerous Commands

#!/bin/bash
COMMAND=$(cat | jq -r '.tool_input.command // empty')
if [ -z "$COMMAND" ]; then exit 0; fi

PATTERNS=('rm\s+-rf\s+/' 'mkfs\.' 'dd\s+if=' 'chmod\s+-R\s+777\s+/' 'curl.*\|\s*bash' '>\s*/dev/sd[a-z]')

for p in "${PATTERNS[@]}"; do
  if echo "$COMMAND" | grep -qE "$p"; then
    jq -n --arg r "Blocked: $p detected" '{hookSpecificOutput:{hookEventName:"PreToolUse",permissionDecision:"deny",permissionDecisionReason:$r}}'
    exit 0
  fi
done
exit 0

Recipe 3: Auto-Run Tests (Async)

#!/bin/bash
INPUT=$(cat)
FILE=$(echo "$INPUT" | jq -r '.tool_input.file_path // .tool_input.path // empty')
if [ -z "$FILE" ]; then exit 0; fi
if ! echo "$FILE" | grep -qE '\.(js|ts|py|go|rs)$'; then exit 0; fi

if [ -f "package.json" ]; then
  npx jest --findRelatedTests "$FILE" --no-coverage >> /tmp/claude-tests.txt 2>&1
elif [ -f "pyproject.toml" ]; then
  python -m pytest --tb=short >> /tmp/claude-tests.txt 2>&1
fi
exit 0

Set "async": true so Claude continues working.

Recipe 4: Log All Tool Usage

#!/bin/bash
INPUT=$(cat)
mkdir -p "$HOME/.claude/logs"
TOOL=$(echo "$INPUT" | jq -r '.tool_name // "unknown"')
SESSION=$(echo "$INPUT" | jq -r '.session_id // "unknown"')
TINPUT=$(echo "$INPUT" | jq -c '.tool_input // {}')

jq -n --arg ts "$(date -Iseconds)" --arg t "$TOOL" --arg s "$SESSION" --argjson i "$TINPUT" \
  '{timestamp:$ts,tool:$t,session:$s,input:$i}' >> "$HOME/.claude/logs/tool-usage.jsonl"
exit 0

Recipe 5: Custom Notifications

#!/bin/bash
INPUT=$(cat)
EVENT=$(echo "$INPUT" | jq -r '.hook_event_name')
case "$EVENT" in
  Notification) MSG=$(echo "$INPUT" | jq -r '.message // "Notification"') ;;
  Stop) MSG="Claude finished responding." ;;
esac

# Desktop
command -v notify-send &>/dev/null && notify-send "Claude Code" "$MSG"

# Slack
[ -n "$SLACK_WEBHOOK_URL" ] && curl -s -X POST "$SLACK_WEBHOOK_URL" \
  -H 'Content-Type: application/json' \
  -d "$(jq -n --arg t "$MSG" '{text:$t}')" || true
exit 0

Hook Locations

Location	Path	Scope
Global	`~/.claude/settings.json`	All projects
Project shared	`.claude/settings.json`	Team-wide
Project local	`.claude/settings.local.json`	Your machine
Managed policy	Org-wide	Enterprise

Advanced Patterns

MCP Tool Matching

{
  "matcher": "mcp__database__execute_query",
  "hooks": [{
    "type": "command",
    "command": ".claude/hooks/check-sql-safety.sh"
  }]
}

The "once" Flag

{
  "type": "command",
  "command": "npm ls --depth=0",
  "once": true,
  "statusMessage": "Verifying dependencies..."
}

Security Best Practices

Never store secrets in configs — use allowedEnvVars
Use script files over inline commands
Set appropriate timeouts
Log hook actions for audit trails
Test hooks locally first
Use /hooks to verify hooks loaded

FAQ

Do hooks work with MCP? Yes. MCP tools follow mcp__<server>__<tool> naming.

Can hooks modify Claude's behavior? Yes. PreToolUse blocks actions, PostToolUse triggers automation.

Exit code 0 vs 2? 0 = allow, 2 = block (PreToolUse).

How to debug? Use /hooks command. Validate JSON with python3 -c "import json; json.load(open('.claude/settings.json'))".

Originally published at serenitiesai.com

AI Agent Skills Guide 2026: Build Skills for 16+ AI Tools

Serenities AI — Fri, 06 Mar 2026 20:11:52 +0000

Imagine writing a set of instructions once and having it work across Claude Code, Cursor, OpenAI Codex, Gemini CLI, VS Code, and a dozen more AI tools. That's exactly what Agent Skills deliver — and they're rapidly becoming the "npm packages" of AI-assisted development.

Announced by Anthropic on December 18, 2025, Agent Skills is an open standard that lets you package expertise, workflows, and automation into portable directories that any compatible AI tool can load and execute. As of March 2026, 16+ major AI tools have adopted the standard.

This isn't a proprietary feature locked to one vendor. It's an industry-wide shift in how we customize and extend AI tools. Think of it like this: if AI coding assistants are the new IDEs, Agent Skills are the extensions marketplace — except one extension works everywhere.

What Are Agent Skills?

Agent Skills is "a simple, open format for giving agents new capabilities and expertise." At the most basic level, a skill is just a directory containing a SKILL.md file. That markdown file tells an AI agent what the skill does, how to use it, and what rules to follow.

The Core Idea: Write Once, Works Everywhere

Before Agent Skills, customizing AI tools meant writing tool-specific configuration. Your Cursor rules didn't work in Claude Code. Your Codex setup didn't transfer to Gemini CLI.

Agent Skills changes that. One skill directory, one SKILL.md file, and it works across every tool that supports the standard — 16+ tools and growing.

Progressive Disclosure

When an AI agent starts up, it doesn't read every skill's full content. It only loads the name and description from the YAML frontmatter. The agent scans those short descriptions, and only when a skill is actually needed does it load the full content.

This means you can have dozens or even hundreds of skills installed without any performance penalty.

The Directory Structure

my-skill/
├── SKILL.md          # Required — the skill definition
├── scripts/          # Optional — executable scripts
├── references/       # Optional — documentation, examples
└── assets/           # Optional — images, templates, configs

Which Tools Support Agent Skills?

The adoption has been remarkable. Within three months, 16+ major AI tools added support:

Tool	Category	Developer
Claude Code	CLI Coding Agent	Anthropic
Claude (web/mobile)	AI Assistant	Anthropic
Cursor	AI Code Editor	Anysphere
OpenAI Codex	CLI Coding Agent	OpenAI
Gemini CLI	CLI Coding Agent	Google
Junie	IDE Agent	JetBrains
GitHub Copilot	AI Pair Programmer	GitHub
VS Code	Code Editor	Microsoft
OpenHands	Autonomous Agent	Open Source
Amp	AI Coding Agent	Sourcegraph
Goose	AI Agent	Block
Firebender	AI Coding Tool	Firebender
Letta	Agent Framework	Letta

When Google, OpenAI, JetBrains, and GitHub all adopt the same standard, you know it's become the real deal.

The SKILL.md Format

Every skill starts with a SKILL.md file with two parts: YAML frontmatter and markdown content.

YAML Frontmatter Fields

Field	Required	Description
name	Yes	Max 64 chars, lowercase + hyphens
description	Yes	Max 1024 chars — what agents read at startup
license	No	SPDX identifier (e.g., MIT)
compatibility	No	Which tools this skill targets
metadata	No	Custom key-value pairs (author, version, tags)
allowed-tools	No	Restrict which tools the skill can access

Example SKILL.md

---
name: code-review
description: "Performs thorough code review with focus on security vulnerabilities, performance issues, and adherence to team coding standards."
license: MIT
compatibility:
  - claude-code
  - cursor
  - codex
metadata:
  author: your-team
  version: 1.0.0
allowed-tools:
  - read
  - write
  - exec
---

Creating Your First Skill: Step by Step

Let's build a "commit-message" skill that generates conventional commit messages.

Step 1: Create the Directory

mkdir -p my-project/.claude/skills/commit-message

Step 2: Write the SKILL.md

Create .claude/skills/commit-message/SKILL.md with name, description, and detailed instructions for analyzing git diffs, categorizing changes (feat/fix/refactor/docs/test/chore), and writing conventional commit messages.

Step 3: Add Optional Scripts

Skills can include executable scripts for validation, testing, or automation.

Step 4: Test It

Open your project in any supported tool and ask: "Write a commit message for my changes." The agent should detect and activate the skill automatically.

Claude Code Skills Deep Dive

Claude Code has the most mature implementation with advanced features:

Skill Locations and Priority

Priority	Location	Path	Use Case
1 (Highest)	Enterprise	Managed by org admin	Company-wide standards
2	Personal	~/.claude/skills/	Your workflow preferences
3	Project	.claude/skills/	Project-specific standards
4 (Lowest)	Plugin	Installed via skills.sh	Community skills

Bundled Skills

/simplify — Spawns 3 parallel review agents analyzing readability, performance, and correctness simultaneously
/batch — Spawns 5-30 worktree agents for large-scale codebase changes
/debug — Interactive debugging workflow that traces through code and proposes fixes

Skills Across Other Tools

Cursor

Cursor reads skills from .claude/skills/ in your project. Migrate your .cursorrules into Agent Skills format and they work in both Cursor AND every other supporting tool.

OpenAI Codex

Codex adopted Agent Skills as its customization format — a significant endorsement from Anthropic's biggest competitor.

Gemini CLI

Google optimized progressive disclosure for fast skill loading. Dozens of skills barely affect startup time.

VS Code

Skills placed in .claude/skills/ are automatically picked up by VS Code's AI assistant. Since VS Code is the most popular editor, this reaches the largest audience.

5 Practical Skill Recipes

Code Review — Security, performance, and style checks with severity-rated output
Test Generator — Generates comprehensive test suites for Jest, Vitest, Pytest, or Go
Documentation Generator — Creates/updates README, API docs, and changelogs from code
Security Audit — OWASP Top 10 analysis with dependency scanning and secrets detection
Codebase Onboarding — Helps new developers understand unfamiliar codebases quickly

Skills Management with skills.sh

The community has built skills.sh — think of it as "npm for agent skills." You can discover, install, and manage skills from a central registry.

Security: 341 Malicious Skills Discovered

With any open ecosystem comes security risks. As of early 2026, 341 malicious skills have been discovered. Protect yourself:

Always set allowed-tools for community skills
Review SKILL.md content before installing
Use enterprise-level skills for sensitive projects
Keep skills version-controlled

How Serenities AI Uses Agent Skills

At Serenities AI, we use Agent Skills to standardize workflows across our integrated platform. Since Serenities AI lets you connect your existing AI subscription (ChatGPT Plus, Claude Pro) instead of paying per-token API costs, skills become even more powerful — you can run complex multi-step skill workflows without worrying about token costs eating into your budget.

FAQ

Do Agent Skills work with all AI tools?

As of March 2026, 16+ tools support the standard, including Claude Code, Cursor, OpenAI Codex, Gemini CLI, VS Code, JetBrains Junie, and GitHub Copilot.

Where should I put my skills?

For project skills: .claude/skills/. For personal skills: ~/.claude/skills/. The directory name is part of the standard, not brand-specific.

Can skills run code?

Yes. Skills can include scripts in the scripts/ directory. Use the allowed-tools field to restrict what untrusted skills can access.

Are Agent Skills free?

The standard itself is open and free. Individual skills may have their own licenses.

Bottom Line

Agent Skills represent a fundamental shift in how we customize AI tools. Write once, works everywhere, with progressive disclosure keeping things fast. Whether you're a solo developer or managing a team of hundreds, skills give you portable, version-controlled AI customization that moves with you across tools.

The ecosystem is still young, but with 16+ tools already on board, this is the standard that's going to define how we extend AI assistants for years to come.

Originally published at serenitiesai.com