LaunchDarkly Agent Skills let you build AI Configs by describing what you want. Tell your coding assistant to create an agent, and it handles the API calls, targeting rules, and tool definitions for you.

In this quickstart, you’ll create AI Configs using natural language, then run a sample LangGraph app that consumes them. You’ll build a “Side Project Launcher”—a three-agent pipeline that validates ideas, writes landing pages, and recommends tech stacks.

Prefer video? Watch Build a multi-agent system with LaunchDarkly Agent Skills for a walkthrough of this tutorial.

What you’ll build

A three-agent pipeline called “Side Project Launcher”:

• Idea Validator: researches competitors, analyzes market gaps, scores viability
• Landing Page Writer: generates headlines, copy, and CTAs based on your value prop
• Tech Stack Advisor: recommends frameworks, databases, and hosting based on your requirements

By the end, you’ll have working AI Configs in LaunchDarkly and a sample app that fetches them at runtime.

Prerequisites

• LaunchDarkly account (free trial works)
• Claude Code, Cursor, or Windsurf installed
• LaunchDarkly API access token (for creating configs)
• Anthropic API key (for running the sample app)

• LaunchDarkly API access token (LD_API_KEY): Used by Agent Skills to create projects and AI Configs. Get it from Authorization settings. Requires writer role or custom role with createProject and createAIConfig permissions.
• LaunchDarkly SDK key (LAUNCHDARKLY_SDK_KEY): Used by your app at runtime to fetch AI Configs. Found in your project’s SDK settings after creation.
• Model provider API key (e.g., ANTHROPIC_API_KEY): Used to call the model. Get it from your provider (Anthropic, OpenAI, etc.).

Store all keys in .env and never commit them to version control.

Want to follow along? Start your 14-day free trial of LaunchDarkly. No credit card required.

30-second quickstart

If you just want to get started, here’s the fastest path:

1. Install skills:

npx skills add launchdarkly/agent-skills

Or ask your editor: “Download and install skills from https://github.com/launchdarkly/agent-skills“

Restart your editor after installing.

2. Set your token:

export LD_API_KEY="api-xxxxx"

3. Build something:

Use the prompt in Build a multi-agent project below, or describe your own agents. The assistant creates everything and gives you links to view them in LaunchDarkly.

Install Agent Skills in Claude Code, Cursor, or Windsurf

Agent Skills work with any editor that supports the Agent Skills specification.

Step 1: Install the skills

You have two options:

Option A: Use skills.sh (recommended)

skills.sh is an open directory for agent skills. Install LaunchDarkly skills with one command:

npx skills add launchdarkly/agent-skills

Option B: Ask your AI assistant

Open your editor and ask:

Download and install skills from https://github.com/launchdarkly/agent-skills

Both methods install the same skills.

Step 2: Restart your editor

Close and reopen your editor. The skills load on startup.

How to verify: Type /aiconfig in Claude Code. You should see autocomplete suggestions. In Cursor, ask “what LaunchDarkly skills do you have?” and the assistant should list them.

Step 3: Set your API token

export LD_API_KEY="api-xxxxx"

Get your token from LaunchDarkly Authorization settings. The writer role works, or use a custom role with createProject and createAIConfig permissions.

Build a multi-agent project

Now let’s build something real: a Side Project Launcher that helps you validate ideas, write landing pages, and pick the right tech stack. Tell the assistant:

Create AI Configs for a "Side Project Launcher" with three configs.
Use Anthropic Claude models for all configs.

1. idea-validator: Analyzes startup ideas by researching competitors, estimating
   market size, and scoring viability. Use variables for {{idea}}, {{target_audience}},
   and {{problem_statement}}. Give it tools for web search and competitor analysis.

2. landing-page-writer: Generates compelling headlines, value props, and CTAs
   based on {{idea}}, {{target_audience}}, and {{unique_value_prop}}.
   Give it tools for copy generation and A/B test suggestions.

3. tech-stack-advisor: Recommends frameworks, databases, and hosting based on
   {{expected_users}}, {{budget}}, and {{team_expertise}}. Give it a tool for
   stack recommendations.

Put them in a new project called side-project-launcher.

What the assistant creates

The assistant uses several skills automatically:

1. aiconfig-projects: creates the LaunchDarkly project
2. aiconfig-create: builds each agent configuration with variables
3. aiconfig-tools: defines tools for function calling

Expected output:

Creating project: side-project-launcher
Creating AI Config: idea-validator
  - Model: anthropic.claude-sonnet-4-20250514
  - Variables: idea, target_audience, problem_statement
  - Instructions: "Validate the idea: {{idea}}. Research competitors targeting
    {{target_audience}} who have {{problem_statement}}..."
  - Tools: web_search, competitor_analysis
Creating AI Config: landing-page-writer
  - Model: anthropic.claude-sonnet-4-20250514
  - Variables: idea, target_audience, unique_value_prop
  - Instructions: "Write landing page copy for {{idea}}. The target audience is
    {{target_audience}}. Lead with: {{unique_value_prop}}..."
  - Tools: generate_copy, suggest_ab_tests
Creating AI Config: tech-stack-advisor
  - Model: anthropic.claude-sonnet-4-20250514
  - Variables: expected_users, budget, team_expertise
  - Instructions: "Recommend a tech stack for {{expected_users}} users,
    {{budget}} budget, team knows {{team_expertise}}..."
  - Tools: recommend_stack

Done! View your project:
https://app.launchdarkly.com/side-project-launcher/production/ai-configs

The variables ({{idea}}, {{target_audience}}, etc.) get filled in at runtime when you call the SDK. That’s how each user gets personalized output.

What it looks like in LaunchDarkly

After creation, your LaunchDarkly project contains:

• 3 AI Configs with instructions, model settings, and variables
• 3 tools with parameter definitions ready for function calling
• Default targeting serving the configuration to all users

Each agent has its own configuration with instructions, variables, and tools. Here’s the idea-validator:

The landing-page-writer and tech-stack-advisor follow the same pattern with their own instructions and tools.

Run the Side Project Launcher

The full working code is available on GitHub: launchdarkly-labs/side-project-researcher

Clone it and run:

git clone https://github.com/launchdarkly-labs/side-project-researcher.git
cd side-project-researcher
pip install -r requirements.txt
cp .env.example .env
# Edit .env with your SDK key and Anthropic API key
python side_project_launcher_langgraph.py

You’ll need both the LaunchDarkly SDK key (from your project’s SDK settings) and your Anthropic API key in the .env file. The assistant can surface the SDK key from your project details, but store it in .env rather than hardcoding it.

The app prompts you for your idea details:

Then each agent runs in sequence, fetching its config from LaunchDarkly and generating output:

Connect to your framework

The AI Config stores your model, instructions, and tools. The SDK fetches the config and handles variable substitution automatically.

The snippets below show the integration pattern. They omit imports, error handling, and tool wiring for brevity. For complete, runnable code, use the sample repo.

Initialize the SDK

import ldclient
from ldclient import Context
from ldclient.config import Config
from ldai.client import LDAIClient, AIAgentConfigDefault

# Initialize once at startup
SDK_KEY = os.environ.get('LAUNCHDARKLY_SDK_KEY')
ldclient.set_config(Config(SDK_KEY))
ld_client = ldclient.get()
ai_client = LDAIClient(ld_client)

Fetch agent configs

def build_context(user_id: str, **attributes):
    """Build LaunchDarkly context for targeting."""
    builder = Context.builder(user_id)
    for key, value in attributes.items():
        builder.set(key, value)
    return builder.build()

def get_agent_config(config_key: str, context: Context, variables: dict = None):
    """Get agent-mode AI Config from LaunchDarkly."""
    fallback = AIAgentConfigDefault(enabled=False)
    return ai_client.agent_config(config_key, context, fallback, variables or {})

Wire it to LangGraph

LangGraph orchestrates multi-agent workflows as a graph of nodes, but you can use any orchestrator—CrewAI, LlamaIndex, Bedrock AgentCore, or custom code. To compare options, read Compare AI orchestrators.

By wiring AI Configs to each node, your agents fetch their model, instructions, and tools dynamically from LaunchDarkly. This lets you swap models within a provider (e.g., Sonnet to Haiku), update prompts, or disable agents without redeploying.

The AI Config defines tool schemas, but your code must implement the actual tool handlers. The sample repo shows how to bind config.tools to LangChain tool functions. For this tutorial, the tools are defined but not wired—the agents respond based on their instructions alone.

Each agent becomes a node in your graph:

from langchain_anthropic import ChatAnthropic
from langchain_core.messages import HumanMessage, SystemMessage
from langgraph.graph import StateGraph, END

def idea_validator_node(state: SideProjectState) -> SideProjectState:
    context = build_context(state["user_id"])
    config = get_agent_config("idea-validator", context, {
        "idea": state["idea"],
        "target_audience": state["target_audience"],
        "problem_statement": state["problem_statement"]
    })

    if config.enabled:
        llm = ChatAnthropic(model=config.model.name)
        messages = [
            SystemMessage(content=config.instructions),
            HumanMessage(content="Please validate this idea and provide your analysis.")
        ]
        response = llm.invoke(messages)
        state["idea_validation"] = response.content
        config.tracker.track_success()  # Track metrics

    return state

# Build the graph
workflow = StateGraph(SideProjectState)
workflow.add_node("validate_idea", idea_validator_node)
workflow.add_node("write_landing_page", landing_page_writer_node)
workflow.add_node("recommend_stack", tech_stack_advisor_node)

workflow.set_entry_point("validate_idea")
workflow.add_edge("validate_idea", "write_landing_page")
workflow.add_edge("write_landing_page", "recommend_stack")
workflow.add_edge("recommend_stack", END)

app = workflow.compile()

# Don't forget to flush before exiting
ld_client.flush()

To see a full example running across LangGraph, Strands, and OpenAI Swarm, read Compare AI orchestrators.

What you can do next

Once your agents are in LaunchDarkly:

• A/B test variations: split traffic between prompt variations or model sizes (e.g., Sonnet vs Haiku) to see which performs better
• Target by segment: premium users get one variation, free users get another
• Kill switch: disable a misbehaving agent instantly from the UI
• Track costs: monitor tokens and latency per variation

To learn more about targeting and experimentation, read AI Configs Best Practices.

Troubleshooting

Skills installed but not working: Restart your editor after installing skills. They load on startup.

“Permission denied” errors: Check that your API token has createProject and createAIConfig permissions. The writer role includes both.

Config comes back disabled: Your targeting rules may not match the context you’re passing. Check that default targeting is enabled, or that your context attributes match your rules.

Tools defined but not executing: The AI Config defines tool schemas, but your code must implement handlers. See the sample repo for tool binding examples.

Can’t find SDK key: After Agent Skills creates your project, find the SDK key in your project’s Settings > Environments > SDK key. Copy it to your .env file.

FAQ

Do I need Claude Code, or does this work in Cursor/Windsurf?

Agent Skills work in any editor that supports the Agent Skills specification. This includes Claude Code, Cursor, and Windsurf. The installation process is the same.

What’s the difference between Agent Skills and the MCP server?

Both give your AI assistant access to LaunchDarkly. Agent Skills are text-based playbooks that teach the assistant workflows. The MCP server exposes LaunchDarkly’s API as tools. You can use either or both.

What permissions does my API token need?

The writer role works, or use a custom role with createProject and createAIConfig permissions.

Where do I see the created AI Configs?

In the LaunchDarkly UI: go to your project, then AI Configs in the left sidebar. Each config shows its instructions, model, tools, and targeting rules.

How do I delete or reset generated configs?

In the LaunchDarkly UI, open the AI Config and click Archive (or Delete if available). Or ask the assistant: “Delete the AI Config called researcher-agent in project valentines-day.”

Can I use this with frameworks other than LangGraph?

Yes. The SDK returns model name, instructions, and tools as data. You wire that into whatever framework you use: CrewAI, LlamaIndex, Bedrock AgentCore, or custom code.

Does this work for completion mode (chat) or just agent mode?

Both. Use ai_client.completion_config() for completion mode (chat with message arrays) or ai_client.agent_config() for agent mode (instructions for multi-step workflows). To learn more, read Agent mode vs completion mode.

Next steps

• Read the Python AI SDK Reference for detailed SDK usage
• Try building a data extraction pipeline to deploy AI Configs with Vercel

Quick verdict

GitHub Copilot and Cursor are the two most popular AI coding tools in 2026, but they take fundamentally different approaches. Copilot is an extension that adds AI to your existing IDE. Cursor is an entirely new IDE built from the ground up around AI. That architectural difference shapes everything – from how each tool handles multi-file editing to how deeply the AI understands your codebase.

If you want the best multi-file editing and agentic coding experience, choose Cursor. Its Composer and Agent mode can rewrite code across dozens of files in a single operation, plan multi-step changes, run terminal commands, and iterate based on errors. No extension-based tool matches this level of integration.

If you want broad IDE support and seamless GitHub integration, choose Copilot. It works in VS Code, JetBrains IDEs, Neovim, Xcode, and Eclipse. Its coding agent runs asynchronously from GitHub Issues, and code review is built into the PR workflow. For teams that live on GitHub, the native integration is unmatched.

If you are a solo developer on a budget, Copilot Pro at $10/month is half the cost of Cursor Pro at $20/month. Both offer free tiers with similar limitations.

If you want the best of both worlds, you can install the Copilot extension inside Cursor and use Copilot for completions alongside Cursor’s Composer and Agent – though most developers find this redundant and pick one.

Why this comparison matters

GitHub Copilot and Cursor represent two competing visions for the future of AI-assisted development. Copilot bets that AI should augment your existing tools – a smart extension that slots into whatever IDE you already use. Cursor bets that AI should be the foundation of the IDE itself – every feature, from the file explorer to the terminal, designed with AI at the center.

The market is massive and growing. GitHub reports over 15 million developers use Copilot. Cursor has grown to over 2 million users since its launch, making it the fastest-growing AI code editor. The question is no longer whether to use an AI coding tool, but which approach – extension or native IDE – delivers more value.

This comparison matters because the choice affects your entire workflow. Switching IDEs is a bigger commitment than installing an extension. If you choose Cursor, you are adopting a new editor. If you choose Copilot, you are adding a feature to your current one. Understanding the trade-offs before committing is worth the time.

At-a-glance comparison

Code completion quality

Both tools deliver excellent inline code completions, but they feel different in practice. Copilot’s completions are fast and reliable – it has been refining its suggestion engine since 2022 and processes billions of completions daily. The suggestions appear quickly, handle boilerplate well, and rarely produce obviously wrong code for common patterns.

Cursor’s completions leverage a custom model called cursor-small that is optimized specifically for code completion speed. In day-to-day use, Cursor’s completions feel slightly more context-aware because the editor indexes your entire codebase locally. When you are writing a function that follows a pattern established elsewhere in your project, Cursor is more likely to suggest code that matches your existing conventions because it has indexed those patterns.

Tab completion behavior differs subtly. Cursor introduced a “tab to accept” flow that predicts your next edit based on context – not just completing the current line but anticipating what you will type next across multiple cursor positions. This predictive editing is something Copilot does not replicate. Instead of waiting for you to position your cursor and start typing, Cursor proactively suggests the next logical edit after you accept a completion.

For raw completion quality on standard coding tasks, the difference is marginal. Both tools handle function signatures, boilerplate, test scaffolding, and common patterns well. The meaningful difference is Cursor’s deeper context awareness from codebase indexing, which produces more project-specific suggestions rather than generic completions.

Chat and assistant capabilities

Copilot Chat

GitHub Copilot Chat is a polished, multi-model chat assistant embedded in your IDE sidebar. You can ask questions about your code, request explanations, generate tests, and get debugging help. Copilot Chat supports multiple models – GPT-4o, Claude Opus 4, and Gemini models on paid plans – letting you switch between reasoning styles depending on the task.

Copilot Chat also includes slash commands like /explain, /tests, /fix, and /doc that streamline common requests. The @workspace agent lets you ask questions about your entire project, though its understanding is limited compared to Cursor’s full codebase indexing on non-Enterprise plans.

The key limitation is context. On Free and Pro plans, Copilot Chat’s understanding of your codebase is limited to the files currently open in your editor plus whatever context the model can infer from the conversation. Codebase-aware chat with knowledge bases is an Enterprise-only feature at $39/user/month. This means most Copilot users are chatting with an AI that has a narrow view of their project.

Cursor Chat

Cursor Chat is built on full codebase indexing from day one. When you open a project in Cursor, it indexes your entire repository locally. Every chat interaction can draw on this index to answer questions about code in files you have never opened, trace dependencies across modules, and understand architectural patterns across your codebase.

You can reference specific files and symbols using @ mentions in chat – @filename.ts, @symbolName, @folder – giving you precise control over what context the AI considers. Cursor also supports @web for searching the internet, @docs for referencing documentation, and @codebase for broad project-wide queries.

The practical difference is significant. Asking “where is the authentication logic implemented?” in Cursor Chat returns accurate, file-specific answers because the index knows where every function and class lives. Asking the same question in Copilot Chat (on non-Enterprise plans) often produces generic guesses or requires you to manually open the relevant files first.

Verdict on chat

Cursor’s chat is more useful for codebase exploration and understanding because of its indexing. If you frequently ask questions like “how does this feature work?” or “where is this function called?” – Cursor answers more accurately. Copilot’s chat is perfectly adequate for explaining code snippets, generating tests for the file you are working on, and general programming questions. The gap narrows significantly on Copilot Enterprise, which adds codebase-aware knowledge bases.

Multi-file editing

This is Cursor’s strongest advantage over Copilot and the primary reason many developers switch.

Cursor Composer

Cursor Composer is a dedicated interface for multi-file editing that goes far beyond what any extension can offer. You describe a change in natural language – “add user authentication with JWT tokens, including the route handlers, middleware, database schema, and tests” – and Composer generates coordinated edits across all the relevant files.

What makes Composer powerful is the workflow:

1. You describe the change and optionally reference specific files for context
2. Composer generates edits across multiple files simultaneously
3. Each file shows an inline diff with additions, deletions, and modifications highlighted
4. You review each change and accept or reject individual edits
5. Changes are applied atomically – all at once or not at all

The diff preview is critical. Unlike chat-based tools that dump code blocks you need to manually copy-paste, Composer shows exactly what will change in each file. You see the before and after side by side, can reject a change to one file while accepting changes to others, and maintain full control over what the AI modifies.

Composer handles large refactoring tasks that would take hours manually. Renaming a concept across 30 files, migrating from one API pattern to another, adding error handling to every route handler – these are the tasks where Composer saves the most time.

Copilot Edits

GitHub Copilot introduced Edits in VS Code to address the multi-file editing gap. You can add files to a working set and describe changes you want applied across them. Copilot generates edits and shows diffs for review.

Copilot Edits is functional and improving rapidly. For straightforward multi-file changes – updating import paths, adding a parameter to a function and all its callers, generating matching test files – it works well. The VS Code integration is clean, and the diff review process is intuitive.

However, Copilot Edits has notable limitations compared to Composer. It struggles with very large change sets (more than a handful of files), sometimes misses files that need updating, and lacks the planning step that Cursor’s Agent mode provides. The working set concept also requires you to manually specify which files to include, whereas Cursor’s Agent can discover relevant files on its own.

Verdict on multi-file editing

Cursor Composer is more capable, more reliable, and more mature. If multi-file editing is important to your workflow – and for most real-world development tasks, it is – this is Cursor’s decisive advantage. Copilot Edits is catching up, but the gap remains meaningful in 2026.

Agent mode

Both tools offer agent capabilities, but with different philosophies.

Cursor Agent

Cursor’s Agent mode operates interactively within your editor. You describe a task, and the agent plans the approach, edits files, runs terminal commands (with your permission), reads compiler and linter output, and iterates until the task is complete. The entire process happens in real-time in your editor, and you can intervene at any step.

The interactive nature of Cursor’s agent is its strength. You can redirect the agent mid-task, add constraints, or correct its approach based on what you see it doing. The feedback loop is tight – seconds between the agent making a change and you evaluating the result.

Cursor Agent works well for tasks like:

• Implementing a new feature from a description
• Fixing a bug by reading error logs and tracing the issue
• Refactoring code to use a new pattern
• Adding tests for existing functionality
• Migrating between frameworks or libraries

Copilot Coding Agent

Copilot’s coding agent runs asynchronously from GitHub Issues. You assign an issue to Copilot, and it creates a branch, writes code, runs tests, and opens a pull request – all without you needing to be present. This background execution model is fundamentally different from Cursor’s interactive approach.

The async model has real advantages for certain workflows. You can assign multiple issues to Copilot overnight and review the pull requests in the morning. For well-specified tasks with clear acceptance criteria (fix this bug, add this endpoint, write these tests), the async agent is productive.

Copilot’s agent also benefits from native GitHub integration. It reads issue descriptions and comments, references existing PRs and code, and creates properly formatted pull requests with descriptions. The entire workflow stays within GitHub, which simplifies review and merging.

Verdict on agent mode

Choose Cursor’s agent for interactive, complex tasks where you need to guide the AI and iterate quickly. Choose Copilot’s agent for well-defined tasks that can run in the background without supervision. Many teams that use both tools assign simple tasks to Copilot’s async agent and tackle complex features interactively in Cursor.

Codebase understanding and context

How well each tool understands your project as a whole is one of the most important differentiators.

Cursor indexes your entire codebase locally on all plans. When you open a project, Cursor creates a semantic index of every file, function, class, and import in the repository. This index powers chat responses, completion suggestions, and Composer’s ability to find and modify relevant files. The indexing happens on your machine, so your code never leaves your local environment (when using privacy mode).

GitHub Copilot’s codebase awareness depends on your plan. On Free and Pro plans, Copilot’s context is limited to open files and conversation history. The @workspace agent provides some project awareness, but it is not as comprehensive as Cursor’s full index. On Enterprise plans ($39/user/month), Copilot supports knowledge bases that index your repositories for codebase-aware chat. This significantly improves Copilot’s understanding, but the feature is locked behind the most expensive tier.

The practical impact is substantial. Cursor understands how files relate to each other, where functions are defined and called, and what patterns your codebase follows – from day one, on the free plan. Getting equivalent understanding from Copilot requires Enterprise pricing. For teams that work on large, complex codebases where understanding the full picture matters, Cursor’s indexing is a major advantage.

IDE experience

This is the most fundamental trade-off in the comparison: extension versus dedicated IDE.

GitHub Copilot: the extension approach

Copilot works as an extension in the IDE you already use. Install it in VS Code, JetBrains (IntelliJ, PyCharm, WebStorm, and others), Neovim, Xcode, or Eclipse, and you get AI capabilities without changing your editor. Your keybindings, themes, extensions, and muscle memory stay intact.

This approach has clear advantages:

• Zero migration cost. You do not need to learn a new editor or reconfigure anything.
• IDE choice. JetBrains users, Neovim users, and Xcode users all get Copilot support. Cursor is only available as its own IDE.
• Extension ecosystem. Copilot coexists with every other VS Code or JetBrains extension you use.
• Team flexibility. Different team members can use different IDEs with the same Copilot subscription.

The limitation is that an extension can only do so much. Extensions cannot deeply modify the editor’s core behavior, rewrite the file system integration, or add fundamentally new UI paradigms. This is why Copilot Edits and agent mode, while functional, feel like features bolted onto VS Code rather than native capabilities.

Cursor: the AI-native IDE approach

Cursor is a complete IDE forked from VS Code and rebuilt with AI at the foundation. Because the Cursor team controls the entire editor, they can integrate AI into every layer – the file explorer, the terminal, the diff viewer, the editing canvas, and the command palette.

The advantages of this approach:

• Deeper integration. Composer’s inline diff view, Agent’s terminal integration, and the tab prediction system are not possible as extensions.
• Unified experience. Every AI feature feels native rather than added on.
• Faster iteration. The Cursor team ships AI features faster because they do not need to work within extension API constraints.
• VS Code compatibility. Since Cursor is a VS Code fork, it supports VS Code extensions, themes, and keybindings. Migration is nearly painless.

The limitation is that you are tied to Cursor’s IDE. If your team uses JetBrains IDEs, or if specific team members prefer Neovim, they cannot use Cursor. The IDE lock-in is real, even though the VS Code compatibility mitigates it significantly.

Verdict on IDE experience

If you use VS Code, switching to Cursor is low-friction and high-reward. Your extensions, settings, and keybindings transfer directly, and you gain access to Composer, Agent, and deeper AI integration. If you use JetBrains, Neovim, or Xcode, Copilot is your only option between these two tools – Cursor does not support those editors.

Pricing comparison

Pricing is one of the clearest differentiators. Copilot is cheaper at every tier.

GitHub Copilot pricing

Cursor pricing

Cost comparison by scenario

The price gap is significant for teams. At $40/user/month versus $19/user/month, Cursor Business is more than double the cost of Copilot Business. For a 50-person engineering team, that is over $12,000 per year in additional spend. The question is whether Cursor’s superior multi-file editing, codebase indexing, and agent capabilities justify that premium.

For individual developers, the calculus is different. Cursor Pro at $20/month includes 500 fast premium requests and all features. Getting comparable functionality from Copilot requires Pro+ at $39/month (for 1,500 premium requests and full model access). If you are a heavy user of AI agent features and multi-file editing, Cursor Pro is actually cheaper than Copilot Pro+.

Cursor’s bring-your-own-key option changes the equation further. If you already pay for an OpenAI or Anthropic API key, you can use it with Cursor without consuming premium requests. This effectively makes Cursor’s usage unlimited for API key holders, which is not possible with Copilot.

Model access

Both tools offer access to frontier AI models, but the details differ.

GitHub Copilot provides multi-model selection on paid plans. Users can choose between GPT-4o, Claude Opus 4, Gemini 3 Pro, and other models depending on their plan tier. The model selection happens in the chat interface, letting you switch between models for different tasks – Claude for detailed analysis, GPT-4o for fast responses, Gemini for alternative perspectives. Model access varies by plan, with Pro+ and Enterprise users getting the broadest selection.

Cursor also supports multiple models including GPT-4o, Claude 3.5 Sonnet, Claude Opus 4, and cursor-small (the custom completion model). The model selection works similarly – choose the model that fits your task in chat, Composer, or Agent sessions.

Cursor’s unique advantage is bring-your-own-key support. You can add your own API keys for OpenAI, Anthropic, Google, and other providers. Requests made with your own key do not count against your premium request quota. This means you can use the latest models the day they are released, without waiting for Cursor to officially add support. Copilot does not support bring-your-own-key – all model access goes through GitHub’s infrastructure.

For most developers, the model access is roughly equivalent. Both tools provide access to the best available models. Cursor’s BYOK option gives power users more flexibility, while Copilot’s model allocation is simpler and does not require managing separate API accounts.

Privacy and enterprise features

Enterprise readiness is an area where Copilot has a clear lead.

GitHub Copilot enterprise features

• IP indemnity on Business and Enterprise plans – GitHub assumes legal liability for Copilot’s output
• Content exclusion – specify files and repositories that Copilot should never reference
• Audit logs – track AI usage across your organization
• SAML SSO – enterprise identity management
• Organization policies – centrally manage what features are available to users
• SOC 2 Type II compliance
• Knowledge bases (Enterprise) – index your repositories for codebase-aware chat
• Custom models (Enterprise) – fine-tune on your organization’s code

Cursor enterprise features

• Privacy mode – ensures no code is stored on Cursor’s servers (available on all plans)
• Centralized billing on Business plan
• Admin controls for team management
• Enforced privacy mode on Business plan – admins can require privacy mode for all users
• SOC 2 Type II compliance

The gap is meaningful for regulated industries. Copilot’s IP indemnity alone can be a deciding factor for legal teams evaluating AI tools. Content exclusion controls, SAML SSO, and comprehensive audit logs are table-stakes requirements for many enterprises. Cursor’s enterprise offering is growing but has not reached parity.

For individual developers and small teams, privacy mode is sufficient. Cursor’s privacy mode prevents your code from being stored on their servers or used for training, which addresses the most common privacy concern. If you do not need IP indemnity, SAML SSO, or enterprise audit trails, Cursor’s privacy posture is adequate.

When to choose GitHub Copilot

You use JetBrains, Neovim, or Xcode. Cursor is only available as its own IDE. If your editor is not VS Code (or a VS Code fork), Copilot is your only option between these two tools. This single factor decides the comparison for many developers.

Your team lives on GitHub. Copilot’s native integration with GitHub Issues, Pull Requests, Actions, and the coding agent creates a seamless workflow. Assigning issues to the Copilot agent, reviewing AI-generated PRs, and using code review in the pull request interface all work without additional configuration.

Budget is a primary concern. Copilot Pro at $10/month is half the cost of Cursor Pro. For teams, Copilot Business at $19/user/month is less than half of Cursor Business at $40/user/month. If the AI coding budget is tight, Copilot provides strong value at a lower price.

Enterprise compliance requirements are strict. IP indemnity, SAML SSO, content exclusion, comprehensive audit logs, and custom models are available on Copilot Enterprise. Cursor’s enterprise features do not yet match this depth.

You prefer minimal disruption to your workflow. Installing an extension is less disruptive than switching editors. If your team has established workflows, keybindings, and muscle memory in their current IDE, Copilot preserves all of that.

When to choose Cursor

Multi-file editing is central to your workflow. If you frequently refactor across files, implement features that span multiple modules, or need to make coordinated changes to related files, Cursor’s Composer is the most capable tool for the job. This is not a small advantage – it is the feature that drives most Copilot-to-Cursor switches.

You work on large, complex codebases. Cursor’s local codebase indexing means every AI interaction understands your full project. For repositories with hundreds of files and complex dependency chains, this context awareness produces dramatically better AI suggestions than Copilot’s limited context on non-Enterprise plans.

You want interactive agent capabilities. Cursor’s Agent mode lets you describe a task and watch the AI implement it in real-time, intervening and redirecting as needed. The tight feedback loop between human guidance and AI execution is more productive for complex tasks than Copilot’s async approach.

You already use VS Code. Since Cursor is a VS Code fork, the migration takes minutes. Your extensions, settings, themes, and keybindings transfer automatically. The risk is low, and you can always switch back.

You want bring-your-own-key flexibility. If you have OpenAI or Anthropic API keys, Cursor lets you use them without consuming premium requests. This can effectively eliminate usage limits for developers with existing API accounts.

Can you use both together?

Yes, and some developers do – though it requires thought about which tool does what.

Since Cursor is a VS Code fork, you can install the GitHub Copilot extension inside Cursor. This gives you access to Copilot’s completions, chat, and code review alongside Cursor’s Composer, Agent, and codebase indexing. In theory, you get the best of both worlds.

In practice, running both inline completion engines simultaneously creates friction. Duplicate suggestions appear, it is unclear which AI generated which recommendation, and the two systems sometimes conflict on what to suggest. Most developers who use both disable one tool’s completions and use each for its strengths:

• Copilot for: inline completions (if you prefer Copilot’s suggestion style), PR code review on GitHub, and the async coding agent for background tasks
• Cursor for: Composer multi-file editing, Agent mode for interactive complex tasks, and codebase-aware chat

The cost of running both is the sum of both subscriptions. Copilot Pro ($10/month) plus Cursor Pro ($20/month) totals $30/month for an individual. For teams, Copilot Business ($19/user/month) plus Cursor Business ($40/user/month) totals $59/user/month per developer.

A more practical approach for most developers is to choose one tool as your primary AI coding assistant and use the other selectively. If you choose Cursor as your IDE, you gain its superior multi-file editing and agent capabilities while still being able to use Copilot’s PR review and async agent on GitHub. If you choose Copilot as your primary assistant, you can open Cursor occasionally for complex refactoring tasks that benefit from Composer.

Alternatives worth considering

The GitHub Copilot vs Cursor comparison does not cover every option. Two other tools deserve mention:

Tabnine is the strongest option for teams with strict privacy requirements. It offers on-premise deployment, VPC hosting, and air-gapped installation – deployment options that neither Copilot nor Cursor provide. Tabnine’s code completion is competitive, and its Enterprise Context Engine understands your codebase. If data sovereignty is non-negotiable, Tabnine is the answer.

Windsurf (by Codeium) takes the same AI-native IDE approach as Cursor. Built as a VS Code fork with deep AI integration, Windsurf offers its own version of multi-file editing (Cascade) and agent capabilities. Its free tier is generous, and its pricing is competitive with Cursor. If you like the idea of an AI-native IDE but want an alternative to Cursor, Windsurf is worth evaluating.

Bottom line

GitHub Copilot and Cursor are both excellent AI coding tools, but they excel at different things.

Cursor wins on AI depth. Multi-file editing via Composer, interactive Agent mode, codebase indexing on all plans, and bring-your-own-key flexibility make it the more powerful AI coding environment. If you want the AI to understand your entire project and make large-scale changes reliably, Cursor is the better tool.

Copilot wins on breadth and accessibility. Support for five IDE families, native GitHub integration, the async coding agent, built-in code review, enterprise compliance features, and a lower price point make it the more practical choice for most teams. If you want AI assistance without switching editors or doubling your tool budget, Copilot delivers strong value.

For individual developers using VS Code, try Cursor’s free tier. The migration is painless, and Composer alone may justify the switch. If it does not change your workflow meaningfully, Copilot at $10/month is the better deal.

For teams, evaluate based on your IDE requirements (Copilot if anyone uses JetBrains or Neovim), your GitHub dependency (Copilot if your workflow is deeply integrated), and your budget sensitivity (Copilot is roughly half the per-seat cost). If your team is all-in on VS Code and multi-file editing productivity matters, Cursor’s premium is justifiable.

The good news is that both tools are improving rapidly. Copilot’s Edits and agent capabilities are closing the gap with Cursor. Cursor’s enterprise features are maturing. Competition between these two tools benefits every developer – whichever you choose today, it will be better six months from now.

Frequently asked questions

Is Cursor better than GitHub Copilot?

Cursor is better for multi-file editing, codebase-aware refactoring, and interactive agentic workflows. GitHub Copilot is better for broad IDE support, GitHub-native integration, enterprise features, and price-sensitive teams. The best choice depends on your specific workflow – developers who frequently refactor across files or work on large codebases tend to prefer Cursor, while teams that need JetBrains support or strict enterprise compliance choose Copilot.

Can I use GitHub Copilot inside Cursor?

Yes, you can install the GitHub Copilot extension in Cursor since it supports VS Code extensions. However, running both inline completion engines simultaneously creates duplicate suggestions and confusion. Most developers disable one tool’s completions and use each for its strengths – for example, Copilot for PR review and Cursor for Composer and Agent mode.

Which is cheaper, GitHub Copilot or Cursor?

Copilot is cheaper at the entry level – $10/month for Pro versus $20/month for Cursor Pro. For teams, Copilot Business at $19/user/month is less than half of Cursor Business at $40/user/month. However, Cursor Pro includes features that require Copilot Pro+ ($39/month) to approximate, and Cursor’s bring-your-own-key option can provide unlimited usage for developers with existing API accounts.

Does Cursor work with GitHub?

Yes, Cursor supports all standard Git operations and works seamlessly with GitHub repositories. You can clone, commit, push, and create pull requests from within Cursor. The GitHub Pull Requests extension also works in Cursor for managing PRs in the editor. Cursor does not have Copilot’s native GitHub Issue-to-PR agent workflow, but day-to-day Git usage is identical to VS Code.

What AI models does Cursor support?

Cursor supports GPT-4o, Claude 3.5 Sonnet, Claude Opus 4, and cursor-small (a custom fast completion model). Pro users can select which model powers chat, Composer, and Agent sessions. Cursor also supports bring-your-own-key for OpenAI, Anthropic, and Google APIs, letting you use any model without consuming premium requests.

Is GitHub Copilot or Cursor better for beginners?

Copilot is better for beginners because it installs as a simple extension in your existing IDE with no learning curve beyond accepting inline suggestions. Cursor requires switching to a new editor and learning features like Composer, Agent mode, and .cursorrules files. Beginners should start with Copilot and consider Cursor once they want more powerful multi-file editing and agentic capabilities.

Can Cursor edit multiple files at once?

Yes, multi-file editing through Composer is Cursor’s standout feature. Describe a change in natural language and Composer applies edits across multiple files simultaneously, showing inline diffs for each file that you can accept or reject individually. Copilot Edits also supports multi-file changes, but Cursor’s implementation handles larger changes more reliably and provides better diff previews.

Does GitHub Copilot have agent mode?

Yes, Copilot has two forms of agent capability. The coding agent runs asynchronously from GitHub Issues – assign an issue to Copilot and it creates a branch, writes code, runs tests, and opens a PR. Copilot Chat in VS Code also supports an agent mode for interactive multi-step tasks. Cursor’s Agent mode is interactive-only, working within your editor session in real-time.

Should I switch from VS Code to Cursor?

If you primarily use AI for inline autocomplete and occasional chat, VS Code with Copilot is sufficient. If you frequently ask the AI to refactor across files, generate entire features, or understand complex codebases, Cursor’s deeper integration justifies the switch. The migration is low-risk since Cursor imports your VS Code extensions, settings, themes, and keybindings automatically.

What is Cursor Composer?

Composer is Cursor’s multi-file editing interface. Describe a change in natural language and it generates coordinated edits across all relevant files, showing inline diffs you can accept or reject. Unlike chat-based tools that show code blocks to copy-paste, Composer directly modifies your files with full diff previews. It is the primary reason most developers switch from Copilot to Cursor.

Is GitHub Copilot better for enterprise teams?

Copilot has a stronger enterprise offering. At $39/user/month, Copilot Enterprise includes IP indemnity, SAML SSO, content exclusion, comprehensive audit logs, codebase-aware knowledge bases, and custom models. Cursor Business at $40/user/month offers admin controls and enforced privacy mode but lacks IP indemnity, SAML SSO, and equivalent compliance certifications. For regulated industries, Copilot’s enterprise features are more mature.

What is the best AI coding tool in 2026?

It depends on your workflow. Cursor is the best AI-native IDE for developers who want deep multi-file editing and agent capabilities. GitHub Copilot is the best extension-based assistant for broad IDE support and GitHub integration. Other strong options include Windsurf (AI-native IDE alternative to Cursor), Claude Code (terminal-based agentic coding), Tabnine (privacy-first with on-premise deployment), and Amazon Q Developer (AWS-centric teams). For most developers, either Cursor or Copilot will provide significant productivity gains.

Frequently Asked Questions

Is Cursor better than GitHub Copilot?

Cursor is better than GitHub Copilot for multi-file editing, codebase-aware refactoring, and agentic workflows where you need the AI to understand and modify large sections of your project simultaneously. Cursor’s Composer and Agent mode can rewrite code across dozens of files in a single operation, which Copilot cannot match. However, GitHub Copilot is better for teams that want a lightweight VS Code extension without switching IDEs, need JetBrains or Neovim support, or prefer to stay within the native GitHub ecosystem. The right choice depends on whether you value deep AI integration (Cursor) or broad IDE compatibility and platform integration (Copilot).

Can I use GitHub Copilot inside Cursor?

Yes, you can install the GitHub Copilot extension inside Cursor since Cursor is a fork of VS Code and supports most VS Code extensions. However, running both Copilot and Cursor’s built-in AI features simultaneously can create conflicts – duplicate suggestions, overlapping inline completions, and confusion about which AI generated which recommendation. Most developers choose one or the other for code completion rather than running both at the same time. If you want to try Cursor while keeping Copilot as a fallback, you can disable Cursor’s inline completions and use only its Composer and chat features alongside Copilot’s autocomplete.

Is Cursor free to use?

Cursor offers a free Hobby plan that includes 2,000 code completions and 50 premium requests per month. Premium requests cover slow model usage for chat, Composer, and Agent mode. The free tier is functional for light use but runs out quickly for full-time development. The Pro plan at $20/month provides unlimited completions and 500 fast premium requests. The Business plan at $40/user/month adds team features, admin controls, and centralized billing. There is no enterprise tier with self-hosted deployment currently available.

Which is cheaper, GitHub Copilot or Cursor?

GitHub Copilot is cheaper at the individual level – $10/month for Copilot Pro versus $20/month for Cursor Pro. Both offer free tiers with similar limitations (50 premium requests and 2,000 completions). For teams, Copilot Business costs $19/user/month while Cursor Business costs $40/user/month. However, Cursor includes more powerful multi-file editing and agent capabilities in its Pro plan that would require Copilot Pro+ at $39/month to approximate. The value comparison depends on whether you use Cursor’s advanced features enough to justify the premium.

Does Cursor work with GitHub?

Yes, Cursor works seamlessly with GitHub. Since Cursor is a VS Code fork, it supports all standard Git operations – cloning repositories, creating branches, committing changes, and pushing to GitHub. You can also install the GitHub Pull Requests and Issues extension inside Cursor for PR management directly in the editor. Cursor does not have the same native GitHub integration that Copilot offers (like assigning Copilot as a PR reviewer), but for day-to-day Git workflows, the experience is identical to VS Code.

What AI models does Cursor use?

Cursor provides access to multiple frontier AI models including GPT-4o, Claude 3.5 Sonnet, Claude Opus 4, and cursor-small (a custom fast model for completions). Pro users can select which model powers their chat, Composer, and Agent sessions. Cursor also supports bringing your own API key for OpenAI, Anthropic, Google, and other providers, which lets you use models without consuming premium requests. GitHub Copilot similarly offers multi-model selection including GPT-4o, Claude Opus 4, and Gemini models on paid plans.

Is GitHub Copilot or Cursor better for beginners?

GitHub Copilot is generally better for beginners. It installs as a simple extension in VS Code, JetBrains, or other IDEs you may already use, requires no learning curve beyond accepting inline suggestions, and its chat interface is straightforward. Cursor requires switching to a new IDE (even though it looks like VS Code), and its most powerful features – Composer, Agent mode, .cursorrules files – require learning new workflows. Beginners who want AI assistance without disrupting their existing setup should start with Copilot and consider Cursor once they outgrow what an extension-based approach can offer.

Can Cursor edit multiple files at once?

Yes, multi-file editing is one of Cursor’s core strengths. Cursor Composer lets you describe a change in natural language and applies edits across multiple files simultaneously – creating new files, modifying existing ones, and updating imports and references. Agent mode extends this further by planning multi-step changes, running terminal commands, and iterating based on lint errors or test failures. GitHub Copilot’s Edits feature also supports multi-file changes in VS Code, but Cursor’s implementation is more mature, handles larger changes more reliably, and provides better diff previews for reviewing AI-generated changes before accepting them.

Does GitHub Copilot have an agent mode like Cursor?

Yes, GitHub Copilot introduced an agent mode in 2025 that can autonomously plan and execute multi-step coding tasks. Copilot’s coding agent can create branches, write code, run terminal commands, execute tests, and open pull requests from issue descriptions. Cursor’s Agent mode provides similar capabilities within the editor – planning changes, editing files, running commands, and iterating on errors. The key difference is that Copilot’s agent runs asynchronously (you can assign it a GitHub Issue and it works in the background), while Cursor’s agent works interactively within your editor session. Both are effective, but they suit different workflows.

Should I switch from VS Code to Cursor?

Switching from VS Code to Cursor is low-risk because Cursor imports your VS Code extensions, settings, themes, and keybindings automatically. The interface is nearly identical. The main reasons to switch are Cursor’s superior multi-file editing (Composer), codebase-aware chat that indexes your entire project, and Agent mode for autonomous coding tasks. If you primarily use AI for inline autocomplete and occasional chat, VS Code with Copilot may be sufficient. If you frequently ask the AI to refactor across files, generate entire features, or understand complex codebases, Cursor’s deeper integration justifies the switch.

What is Cursor Composer?

Cursor Composer is a multi-file editing interface that lets you describe changes in natural language and see edits applied across your entire project. Unlike traditional chat-based AI assistants that show you code snippets to copy-paste, Composer directly modifies your files and shows inline diffs you can accept or reject. You can reference specific files, provide context from your codebase, and Composer will generate coordinated changes across all relevant files. It is Cursor’s most differentiated feature compared to GitHub Copilot and the primary reason many developers switch from Copilot to Cursor.

Is GitHub Copilot better for enterprise teams?

GitHub Copilot has a stronger enterprise offering. Copilot Enterprise at $39/user/month includes organization-wide policy management, audit logs, IP indemnity, SAML SSO, content exclusion controls, and codebase-aware chat with knowledge bases. Copilot Business at $19/user/month provides admin controls and compliance features. Cursor Business at $40/user/month offers centralized billing, admin controls, and enforced privacy mode, but lacks IP indemnity, SAML SSO, and the same depth of compliance certifications. For organizations with strict security, compliance, or legal requirements, Copilot’s enterprise features are more mature.

Can I use my own API key with Cursor?

Yes, Cursor supports bringing your own API key for OpenAI, Anthropic, Google, and other providers. When you use your own API key, requests do not count against your monthly premium request quota. This is useful for developers who want unlimited AI usage without upgrading to a higher plan, or who need access to specific models not included in Cursor’s default lineup. GitHub Copilot does not support bring-your-own-key – all usage goes through GitHub’s infrastructure and model allocation.

What is the best AI coding tool in 2026?

The best AI coding tool in 2026 depends on your workflow. Cursor is the best choice for developers who want deep AI integration with multi-file editing, codebase awareness, and agent capabilities in a dedicated AI-native IDE. GitHub Copilot is the best choice for teams that want broad IDE support, seamless GitHub integration, and a lightweight extension-based approach. Other strong contenders include Windsurf (similar to Cursor with its own IDE), Claude Code (terminal-based agentic coding), and Amazon Q Developer (for AWS-centric teams). For most individual developers writing code daily, either Cursor or Copilot will provide significant productivity gains.

Originally published at aicodereview.cc

JSON for Beginners: What It Is and Why Developers Use It

If you are learning web development, you will see JSON everywhere.

APIs return it. Frontend apps send it. Backend tutorials mention it like everybody was born knowing what it means.

They were not.

JSON is one of those things that sounds technical at first, but the core idea is very simple.

JSON is just a text format for organizing data in a way that humans and computers can both read.

That is the big idea.

In this post, we will break it down in plain English, look at a small example, and explain why developers use it so often.

What does JSON stand for?

JSON stands for JavaScript Object Notation.

That name makes it sound like JSON only matters in JavaScript.
It does not.

Today, JSON is used by many languages and tools, including:

• JavaScript
• PHP
• Python
• Laravel
• Node.js
• mobile apps
• third-party APIs

So even though the name comes from JavaScript, JSON is now a general-purpose data format.

What problem does JSON solve?

Programs often need to exchange information.

For example:

• a frontend app asks a backend for user data
• a mobile app sends login details to an API
• one service sends order information to another service

For that exchange to work well, both sides need the data in a structure they can understand.

That is where JSON helps.

It gives data a clear shape.

Instead of sending a messy string like this:

name=Henry, age=27, isStudent=false

You can send something structured like this:

{
  "name": "Henry",
  "age": 27,
  "isStudent": false
}

That second version is easier to read, easier to parse, and easier to trust.

What does JSON look like?

JSON is built from two common ideas:

• objects → data grouped with named keys
• arrays → lists of values

Here is a simple JSON object:

{
  "name": "Ada",
  "role": "Backend Developer",
  "learning": "APIs"
}

And here is JSON with an array inside it:

{
  "name": "Ada",
  "skills": ["PHP", "Laravel", "MySQL"]
}

You can think of it like labeled boxes.
Each key gives a name to the value beside it.

Common JSON value types include:

• strings → "hello"
• numbers → 42
• booleans → true or false
• arrays → [1, 2, 3]
• objects → { "key": "value" }
• null

A very beginner-friendly example

Imagine you have a small app that displays a user profile.
The server might send back data like this:

{
  "id": 7,
  "name": "Henry",
  "email": "[email protected]",
  "isAdmin": false
}

Your app can now read those keys and show them on the page.

• name can be displayed in the profile header
• email can be shown under contact details
• isAdmin can control whether admin buttons appear

That is why JSON matters in real projects.
It gives your app data in a predictable format.

Why do developers use JSON so much?

A few reasons:

1. It is readable

Even beginners can usually look at JSON and make a decent guess about what it means.

2. It is lightweight

JSON is plain text, so it is easy to send over the web.

3. Most languages support it

You do not need to invent your own format.
Most modern languages already know how to create and read JSON.

4. It works well with APIs

A huge number of APIs send responses in JSON, so learning it early pays off fast.

JSON vs JavaScript object: are they the same thing?

Not exactly.
They look similar, which is why beginners mix them up.

A JavaScript object might look like this:

const user = {
  name: "Henry",
  age: 27,
};

JSON looks like this:

{
  "name": "Henry",
  "age": 27
}

Important differences:

• JSON keys use double quotes
• JSON is data, not executable code
• JSON does not allow things like functions or trailing commas

So JSON is similar to a JavaScript object, but it is not the same thing.

Where you will meet JSON in real life

If you keep learning backend or frontend development, you will probably see JSON in places like these:

• API responses
• request bodies
• configuration files
• database exports
• webhooks
• frontend state passed around between services

In Laravel, for example, returning JSON from a route can be as simple as this:

Route::get('/api/profile', function () {
    return response()->json([
        'name' => 'Henry',
        'role' => 'Developer',
        'learning' => 'JSON'
    ]);
});

That route sends data back as JSON.

Beginner mistakes to avoid

A few common ones:

1. Forgetting double quotes around keys

This is valid JSON:

{ "name": "Henry" }

This is not valid JSON:

{ name: "Henry" }

2. Using single quotes

JSON uses double quotes for strings.
Single quotes are a common beginner mistake.

3. Adding trailing commas

This is invalid JSON:

{
  "name": "Henry",
}

That last comma can break parsing.

4. Treating JSON like a programming language

JSON only describes data.
It does not run logic.
It is a format, not a full language.

Final takeaway

If you remember only one thing, remember this:

JSON is a text-based format for organizing and exchanging data.

That is why developers use it so often.

It is simple, readable, and incredibly useful once you start working with APIs and modern web apps.

And honestly, once JSON stops looking scary, a lot of beginner backend tutorials start making much more sense.