Loading…
Cursor
AI-powered code editor designed to make developers extraordinarily productive through intelligent coding assistance
- 126 posts summarised
- latest
The Good Stuff
Paid picks we use ourselves. Links carry a referral code — a subscription through one earns us a commission at no extra cost to you.
From their blog
Latest articles
How Stripe rolled out a consistent Cursor experience for 3,000 engineers
Stripe rolled out Cursor to more than 3,000 engineers while preserving its standards for developer experience and API uptime. The company preloaded Cursor on every machine, taught it in onboarding labs alongside VS Code and IntelliJ, and used Cursor Rules to supply codebase and coding-standard context, with teams able to add local rules. Adoption was reinforced by power users, while code review evolved to use LLMs to flag complex methods and risky files so reviewers could focus attention without sacrificing quality. An internal survey found developer sentiment at a five-year high, and MacVicar observed the largest productivity gains among longest-tenured engineers rather than junior developers. That finding has prompted exploration of letting new hires learn the codebase before receiving Cursor access, reinforcing MacVicar’s advice to start before every AI-workflow question is settled.
Extend Cursor with plugins
Cursor now supports plugins, allowing agents to connect to external tools and acquire new knowledge. Plugins bundle MCP servers, skills, subagents, rules, and hooks to add custom functionality. The initial curated set includes Amplitude, AWS, Figma, Linear, Stripe, Cloudflare, Vercel, Databricks, Snowflake, and Hex, covering planning, design, payments, infrastructure, data, and analytics workflows. Users can install prebuilt plugins from the Cursor Marketplace or create and share their own, while plugin primitives let agents discover domain-specific skills, run subagents in parallel, connect through MCP servers, observe behavior with hooks, and follow rules. The announcement also introduces the Cursor Team Kit for internal CI, code review, and testing workflows, and says private team marketplaces with governance and security controls are coming.
Box chooses Cursor for enterprise-grade quality, security, and control
Box selected Cursor as its enterprise agentic coding platform after evaluating data privacy, security, and agent-quality controls. More than 85% of Box developers, or over 800 people, now use Cursor daily, while the company reports a 30–50% increase in product-roadmap throughput and migrations completed 80–90% faster. Box encodes agent guardrails in custom Cursor rules and commands, including a frontend AI toolkit, automated test-coverage work, and rules for React and design-system migrations. A mentorship program pairing power users with newer adopters increased Cursor usage by 75% and power users by 25% in six weeks, while Box says it can move faster without compromising product quality, security, or accessibility.
Expanding our long-running agents research preview
Cursor has expanded its long-running agents research preview to all Ultra, Teams, and Enterprise users. The preview targets autonomous work on ambitious projects, using a custom harness designed to address frontier models’ failures on long-horizon tasks. Long-running agents propose a plan for approval before execution and use multiple agents to check work and maintain follow-through. Reported examples include runtimes of 36, 30, and 25 hours, while initial results showed substantially larger PRs with merge rates comparable to other agents. Internal examples include a Rust migration and custom kernels for video rendering, a 10,000-line network-policy PR, and secure sudo prompting for Cursor CLI; the company says agents can now deliver working solutions after hours or days, though safer production deployment and collaboration across agents remain active areas.
Increased usage for agents
Cursor has raised limits for Auto and Composer 1.5 for all individual plans. The update introduces separate first-party models and API usage pools: first-party usage is increased for Auto and Composer 1.5, while API pricing and plan allowances remain unchanged. Composer 1.5 has a standard limit of three times Composer 1’s, with a temporary increase to six times through February 16. Cursor says this supports developers moving from autocomplete toward daily agentic coding while accommodating different preferences for speed, intelligence, and affordability. Composer 1.5 is described as scoring above Sonnet 4.5 on Terminal-Bench 2.0 but below the best frontier models, and both pools reset with the monthly usage cycle; the limits are live for Pro, Pro Plus, and Ultra plans.
Introducing Composer 1.5
Composer 1.5 is the successor to the first agentic coding model, Composer 1, and is positioned for fast, interactive daily use. It was built by scaling reinforcement learning 20x further on the same pretrained model, with post-training compute exceeding the base model’s pretraining compute. In an internal benchmark of real-world coding problems, performance quickly surpasses Composer 1 and continues rising, with the largest gains on challenging tasks. Composer 1.5 generates thinking tokens to reason about codebases and plan next steps, using minimal thinking on easy problems and continuing until it finds a satisfying answer on hard ones. It also recursively self-summarizes when context runs out, a training behavior intended to preserve original accuracy as context length varies; the release is described as significantly stronger and suitable for interactive use.
NVIDIA commits 3x more code across 30,000 developers with Cursor
NVIDIA has deployed Cursor across its software development lifecycle, with more than 30,000 developers using it daily and committing over three times as much code as before. NVIDIA’s long-lived, interdependent codebases and varied technology stacks made it difficult to understand downstream effects and keep pace with rapid change. Cursor maps and semantically reasons over large codebases, retrieving relevant context, while custom rules and MCP servers extend it from code generation into reviews, testing, debugging, issue-driven fixes, CI troubleshooting, and git-flow automation. The company also uses it to help new hires learn unfamiliar systems and experienced engineers work across programming languages and stack areas. NVIDIA reports that bug rates have remained flat despite higher coding velocity, while code-style consistency has improved.
Towards self-driving codebases
The post describes research into scaling long-running autonomous coding agents, using a web browser as a complex benchmark and running thousands of agents continuously for one week. An initial single-agent plan failed because the model lost track, stopped prematurely, and stalled on complex details; shared-state coordination then introduced locking contention, while more structured planner, executor, worker, and judge roles improved ownership and throughput. The team built a Rust-based harness on one large Linux VM, logged agent messages and tool activity for replay and analysis, and iterated through designs that eventually favored a more dynamic system with freshness mechanisms and fewer overloaded roles. The research concludes that architecture, prompts, observability, explicit throughput trade-offs, and anti-fragile recovery matter, reporting linear scaling of token throughput with minimal harness overhead while humans retained taste, judgment, and direction.
Securely indexing large codebases
Cursor describes a secure way to index large codebases for semantic search, where naive processing can delay availability for hours. The system builds a Merkle tree of file and directory hashes, synchronizes only divergent branches, and caches embeddings by chunk content to reduce repeated work. For new users, a client-generated simhash finds a similar index within the same team or user's indexes, which is copied while background synchronization reconciles differences. Content proofs derived from the client's full Merkle tree filter search results so users see only files they can prove they possess. Reported time-to-first-query falls from 7.87 seconds to 525 milliseconds for the median repository, and from 4.03 hours to 21 seconds at the 99th percentile.
Dropbox uses Cursor to index over 550,000 files and build an AI-native SDLC
Dropbox adopted Cursor to increase software-development velocity across a demanding environment: its own data centers handle more than 300,000 requests per second, while thousands of engineers maintain a monorepo exceeding 550,000 files. Engineers first experimented organically in 2024, then AI champions, easier sign-up, and a company-wide hackathon helped broaden adoption; CTO Ali Dasdan’s two-hour “smart finder” experience reinforced executive support. Cursor indexed the monorepo by scanning non-ignored files, splitting code into structured chunks, and generating embeddings for a semantic index that supports code generation and editing. More than 90 percent of engineers now use AI tools weekly, with Cursor appearing across coding, review, testing, documentation, and migrations. Dropbox reports that PR throughput and cycle time have moved into the upper tier of industry benchmarks, while describing an ongoing redesign of its software-development lifecycle.
Salesforce accelerates velocity by over 30% and ships higher-quality code with Cursor
Salesforce has made Cursor available to thousands of engineers working across a codebase built over more than 25 years, and reports more than 30% higher velocity alongside gains in code quality. Junior engineers used it to understand existing code and contribute more effectively, while senior engineers began with tedious tasks before expanding to higher-value work as trust grew. Adoption spread from small groups that demonstrated impact, and AI eventually reached every part of the software development lifecycle rather than code writing alone. Salesforce tracks cycle time, quality measured by bug count, and throughput; it reports double-digit improvements across all three, an 85% reduction in one team’s legacy code coverage time, and far more unit tests generated with Cursor.
Building a better Bugbot
Bugbot is a code review agent built to identify logic bugs, performance issues, and security vulnerabilities in pull requests before production, as increasingly capable coding agents increased review workload. Its development moved from qualitative assessments to systematic experimentation, using an AI-driven resolution-rate metric, the BugBench benchmark, and online evaluations of real pull requests. An early production flow ran eight parallel passes with randomized diff ordering, majority voting, category filters, validation, and deduplication, while later versions adopted a fully agentic design with tools and dynamic context. Across 40 major experiments, resolution rate rose from 52% to over 70%, bugs flagged per run from 0.4 to 0.7, and resolved bugs per pull request from roughly 0.2 to about 0.5. Newer versions caught more bugs without a comparable rise in false positives, and planned capabilities include Autofix, self-verification, deep research, and continuous scanning.
Scaling long-running autonomous coding
The post reports experiments running coding agents autonomously for weeks, with hundreds concurrently contributing to projects that typically take human teams months. It describes initial dynamic coordination through shared files, locks, and optimistic concurrency control, then explains why flat peer structures caused bottlenecks, fragility, risk aversion, and stalled progress. The successful design separates recursive planners from task-focused workers, uses a judge between cycles, and lets workers push changes to a shared branch with minimal conflicts. In tests, agents built a browser with more than 1 million lines across 1,000 files, migrated Solid to React over three weeks with +266K/-193K edits, and delivered a 25x faster Rust video renderer; other projects remain underway. The authors say GPT-5.2 models perform better on extended autonomous work, role-specific models and carefully tuned prompts matter, and moderate structure outperforms both flat peer coordination and elaborate controls, though drift and scheduling remain unsolved.
Best practices for coding with agents
Cursor's guide presents practices for using coding agents that can run for hours, complete multi-file refactors, and iterate until tests pass. Planning first is emphasized: Plan Mode researches the codebase, asks clarifying questions, creates a reviewable implementation plan, and waits for approval. The guidance recommends letting the agent discover context, starting new conversations when focus declines, and using Rules for persistent project instructions while Skills provide dynamic workflows. It also describes hooks for long-running loops, worktrees for isolated changes, parallel model runs, cloud agents, and Debug Mode's hypothesis-and-instrumentation process. Careful diff review, specific prompts, and verifiable goals remain necessary because generated code can be subtly wrong.
Dynamic context discovery
Cursor describes dynamic context discovery, a coding-agent pattern that provides fewer details initially and lets the agent retrieve relevant information instead of injecting everything as static context. The approach uses files as a simple interface: long tool responses, chat history, Agent Skills, MCP tool descriptions, and integrated terminal output are stored or synchronized so the agent can inspect only what it needs with tools such as tail, grep, rg, and jq. For MCP, only tool names are included initially, while descriptions are synced into one folder per server; an A/B test found a 46.9% reduction in agent tokens for runs that called an MCP tool, with high variance based on the number of MCPs. Cursor says the design reduces context bloat, preserves information truncation could lose, supports recovery after summarization, and can expose MCP re-authentication status. The changes are planned to become available to all users in the coming weeks.
Hooks for security and platform teams
Cursor has announced ecosystem partnerships around hooks, which run before or after defined stages of its agent loop to observe, block, or modify behavior. The integrations target MCP governance, code security, dependency scanning, agent safety, and secrets management, connecting Cursor with security tooling, observability platforms, secrets managers, and compliance systems. MintMCP, Oasis Security, and Runlayer provide MCP inventory, least-privilege enforcement, audit trails, and centralized tool-interaction visibility, while Corridor and Semgrep give coding-time feedback and vulnerability scanning. Endor Labs intercepts package installations to scan for malicious dependencies, Snyk’s Evo Agent Guard reviews agent actions for prompt injection and dangerous tool calls, and 1Password validates that all required environment files from 1Password Environments are properly mounted before shell commands execute, enabling just-in-time secrets access without writing credentials to disk.
A visual editor for the Cursor Browser
Cursor has released a visual editor for its Browser that combines a web app, codebase, and visual editing tools in one window. Users can drag rendered elements across the DOM tree, inspect React component props, adjust styles and design-system color tokens, and interactively test layout, typography, and component variants. Point-and-prompt interactions let users select interface elements and describe changes such as resizing, recoloring, or reordering; agents run these prompts in parallel and make changes live within seconds. Once a visual arrangement is settled, the agent locates relevant components and updates the underlying code. The release positions the editor as a way to connect visual design and coding more directly, with features documented for Cursor 2.2.
Introducing Debug Mode: Agents with runtime logs
Debug Mode is an agent loop for coding bugs that combines runtime information with human verification, addressing issues that can stump conventional coding agents. After the user describes a bug, it reads the codebase, proposes multiple hypotheses, and instruments the code with logging statements designed to test them. The user reproduces the issue while the agent collects variable states, execution paths, and timing information, then uses those logs to identify a root cause and produce a targeted fix, often a two- or three-line modification. The user reproduces the bug again with the fix; if it works, the agent removes its instrumentation, while a failed verification prompts additional logging and refinement until the user considers the problem solved.
Improving Cursor’s agent for OpenAI Codex models
Cursor describes adapting its agent harness for OpenAI's latest frontier coding model, GPT-5.1-Codex-Max, by pairing model-familiar instructions with Cursor-specific tools and tuning against Cursor Bench. The Codex integration adopts a more shell-forward design, aligns tool names with commands such as rg, explicitly prefers tools over shell commands, and uses sandboxing to limit unauthorized file and network access. It also limits reasoning summaries to one or two sentences, gives literal guidance for invoking read_lints after substantive edits, removes mid-turn user-communication language, and biases the agent toward taking action unless a plan is requested. Preserving Responses API reasoning items is treated as critical: Cursor reports a 30% performance drop for GPT-5-Codex when traces were removed, compared with OpenAI's observed 3% SWE-bench degradation for GPT-5, while prompt-ordering lessons led it to remove wording that discouraged ambitious work.
Past, Present, and Future
Cursor has announced a $2.3 billion Series D financing at a $29.3 billion post-money valuation, nearly two years after describing a vision for an AI-assisted code editor that could make programming more helpful, answer codebase questions instantly, and reduce the visibility of source code. The company says the early stages of that vision are taking shape while substantial work remains to realize Cursor’s potential. It reports a team of more than 300 engineers, researchers, designers, and operators, over $1 billion in annualized revenue, millions of developers and major engineering organizations as customers, and in-house models generating more code than almost any other LLMs in the world. Existing investors Accel, Thrive, and Andreessen Horowitz participated alongside new partners Coatue, NVIDIA, and Google, while the funding will support further research and Cursor’s next magical moments.
Topics they write about
All topics →Weekly digest
The best engineering reads, once a week.