SessionStart and SessionStop hook events

Codex CLI added SessionStart and SessionStop lifecycle hook events, enabling setup and teardown automation around coding sessions. Hooks can initialize development environments, sync state, or generate session summaries automatically. [GitHub Releases ↗]

Smart Approvals via guardian subagents in v0.115.0

Codex CLI v0.115.0 introduced Smart Approvals, using lightweight guardian subagents to evaluate potentially risky operations before execution. Guardians run predefined safety checks and can auto-approve low-risk actions while escalating dangerous ones to the user. [GitHub Release ↗]

Warp adds MCP auto-detection from project config files

Warp now automatically detects MCP server configurations from other tools config files in the project (.cursor/mcp.json, .claude/mcp.json, .vscode/mcp.json) and offers to connect to them. This eliminates duplicate MCP configuration when switching between tools. [Warp Docs ↗]

Amp drops VS Code and Cursor extensions, goes terminal-first

Amp discontinues its VS Code and Cursor extensions to focus exclusively on its terminal-native experience. The decision follows low adoption of the IDE extensions compared to the terminal client. Existing extension users should migrate to the Amp CLI, which offers the same capabilities plus shell integration.

Uninstall the Amp VS Code/Cursor extension. Install the Amp CLI via `npm install -g @anthropic/amp`. Your .amp/ project configuration and skills are compatible with both, no changes needed.

Automations: always-on background agents

Cursor introduced Automations, enabling always-on background agents that monitor file changes, run tests, and perform code review automatically. Automations are configured via .cursor/automations/ and can trigger on file save, git commit, or custom events. [Cursor Docs ↗]

Kiro CLI v1.27 ships /agent create command

Kiro CLI v1.27 adds the /agent create interactive command for scaffolding new subagent definitions. The wizard prompts for agent name, persona, tools, and trigger patterns, then generates the .kiro/agents/*.md file. Also includes /agent list and /agent test for managing custom agents. [Kiro Changelog ↗]

Plugin system and marketplace for Codex CLI

Codex CLI launched its plugin ecosystem with an npm-based marketplace. Plugins can add custom tools, output formatters, and integration hooks. Configuration is managed through the plugins array in codex.json. [GitHub Releases ↗]

Roo Code deprecates XML tool protocol in favor of native tool calling

Roo Code transitions from XML-based tool invocation to native function calling supported by modern LLM APIs. The XML protocol that wrapped tool calls in <tool_use> tags is deprecated and will be removed in v3.0. Native tool calling reduces token overhead and improves reliability.

No action needed for most users. Custom MCP servers that parse XML tool responses should migrate to standard MCP tool calling. Set roo.legacyXmlTools: true in settings to temporarily re-enable the old format.

Junie CLI beta enables headless agent execution

JetBrains releases a beta CLI for Junie that runs outside the IDE. The CLI supports project analysis, code generation, and test execution with the same agent capabilities as the IDE version. Reads .junie/ config directory and supports MCP servers. Designed for CI/CD and scripted workflows. [JetBrains Blog ↗]

Warp adopts AGENTS.md as primary config over WARP.md

Warp AI agent now reads AGENTS.md as its primary project context file, deprecating the custom WARP.md format. Existing WARP.md files continue to work but are loaded with lower priority. The migration aligns Warp with the cross-tool AGENTS.md standard used by Copilot, Codex, and Jules.

Rename WARP.md to AGENTS.md in your project root. If you have both files, AGENTS.md takes priority. Warp-specific directives (like terminal profiles) should move to .warp/ config directory.

MCP Apps in agent chats

Cursor added MCP Apps support in agent chat mode, allowing MCP servers to render rich UI components directly within Cursor conversations. This enables interactive dashboards, forms, and previews powered by MCP tool servers. [Cursor Docs ↗]

Kiro introduces MCP Registry Governance for enterprise teams

Kiro adds MCP Registry Governance, allowing enterprise admins to curate and approve MCP servers available to developers. The governance layer includes allow/deny lists, audit logging, and per-team server scoping. Configuration lives in .kiro/mcp-governance.json at the organization level. [Kiro Blog ↗]

Permission-profile config language in v0.113.0

Codex CLI v0.113.0 introduced a declarative permission-profile configuration language, allowing users to define granular access policies (file read/write, network, shell) in codex.json. Profiles can be shared across teams and enforced in CI environments. [GitHub Release ↗]

Agent Browser Protocol enters public beta

The Agent Browser Protocol (ABP) entered public beta, standardizing how AI agents interact with web browsers for testing, scraping, and automation tasks. Early adopters include Devin, Jules, and several agent frameworks building browser-capable agents.

Qodo Command CLI launches with --mcp flag

Qodo releases a standalone CLI tool that brings code review and test generation to the terminal. The --mcp flag connects to local MCP servers for extended tool access. Supports CI/CD integration with machine-readable JSON output and exit code conventions. [GitHub ↗]

settings.json gains skills and context sections

Gemini CLI v0.33.0 added dedicated skills and context sections to settings.json. Skills define reusable agent capabilities with tool dependencies, while the context section controls automatic file inclusion rules, replacing the need for manual @-file references. [GitHub Releases ↗]

Roo Code CLI pre-release for headless agent execution

Roo Code ships a pre-release CLI that enables running Roo Code agents from the terminal without VS Code. The CLI supports all custom modes defined in .roomodes and reads the same .roo/rules/ configuration. Designed for CI/CD integration and batch processing workflows. [GitHub Release ↗]

Devin v3 API released for programmatic task management

Devin ships v3 of its REST API with full task lifecycle management, webhook support, and streaming session output. The API enables building custom integrations, triggering Devin from CI/CD pipelines, and monitoring task progress programmatically. Breaking change: v2 API endpoints are deprecated with 6-month sunset. [Devin API Docs ↗]

Plugin system and marketplace launch

Claude Code launched a plugin system with an accompanying marketplace, allowing third-party developers to extend Claude Code with custom tools, slash commands, and integrations. Plugins are declared in settings.json and can be scoped per-project or globally. [Anthropic Docs ↗]

New config files: ~/.copilot/config.json and mcp-config.json

Copilot added two new configuration files: ~/.copilot/config.json for global user preferences (model selection, feature flags) and .github/mcp-config.json for project-level MCP server declarations. Both use JSON format with schema validation. [GitHub Docs ↗]

Zed implements ACP Registry and spawn_agent for multi-agent workflows

Zed adds support for the Agent Communication Protocol (ACP) registry, allowing agents to discover and spawn other agents within the editor. The spawn_agent API enables Zed extensions to create specialized sub-agents for tasks like code review, refactoring, or documentation generation. [Zed Blog ↗]

Kiro adds pre/post task execution hooks

Task execution hooks allow Kiro to run shell commands or scripts before and after agent tasks. Hooks are defined in .kiro/hooks.json with pre_task and post_task arrays. Common uses include running linters after code generation, syncing dependencies, or notifying external systems. [Kiro Docs ↗]

MCP governance features for enterprise deployments

Amazon Q added MCP governance capabilities, enabling organization administrators to define approved MCP server allowlists, enforce transport encryption requirements, and audit MCP tool usage across teams via AWS CloudTrail integration. [AWS Docs ↗]

Devin adds Skills framework for custom workflows

Devin 2.0 introduces Skills, reusable workflow templates that encode multi-step procedures. Skills can be created from successful task recordings, defined in YAML, or imported from the Devin Skills marketplace. Each skill specifies prerequisites, steps, validation criteria, and rollback procedures. [Devin Docs ↗]

JetBrains support via Agent Communication Protocol (ACP)

Cursor extended its agent capabilities to JetBrains IDEs through the Agent Communication Protocol (ACP). JetBrains users can now connect to Cursor agent services and share .cursor/rules/ configurations across both editors. [Cursor Docs ↗]

Roo Code adds MCP tool governance and approval workflows

Roo Code introduced MCP tool governance features, allowing workspace administrators to define approved MCP servers in .roo/mcp-policy.json. Unapproved servers trigger user confirmation prompts, and usage is logged for audit trails. [GitHub Releases ↗]

Kiro adds custom subagent definitions via .kiro/agents/*.md

Kiro now supports user-defined subagents through Markdown files in .kiro/agents/. Each file defines an agent persona with a system prompt, allowed tools, and trigger conditions. Subagents can be invoked by name in chat or triggered automatically based on file glob patterns. [Kiro Docs ↗]

Qodo 2.0 introduces multi-agent architecture

Qodo 2.0 rebuilds around a multi-agent architecture with specialized agents for code review, test generation, and documentation. Agents collaborate through a shared context protocol and can be customized via .qodo/agents/ configuration directory. The review agent now generates fix suggestions alongside findings. [Qodo Blog ↗]

Roo Code adds AGENTS.md and AGENTS.local.md support

Roo Code now reads AGENTS.md for shared project instructions and AGENTS.local.md for developer-specific overrides. The local file is automatically added to .gitignore. Both files are loaded as system context alongside existing .roo/rules/ definitions, with local taking highest priority.

GitHub Copilot CLI reaches general availability

GitHub Copilot CLI graduated from preview to GA, offering terminal-based access to Copilot agent capabilities. The CLI reads ~/.copilot/config.json for global settings and .github/copilot-instructions.md for project context. [GitHub Blog ↗]

--allowed-tools flag deprecated for policy engine

Gemini CLI deprecated the --allowed-tools CLI flag in favor of the new policy engine in settings.json. The policy section provides richer tool access control with allow/deny lists, glob patterns, and conditional rules based on context. [GitHub Releases ↗]

Replace --allowed-tools flags with a policy.tools section in settings.json. Use allow and deny arrays with glob patterns for fine-grained control.

Bolt adds MCP support for deployment pipeline integration

Bolt integrated MCP client support, enabling connections to deployment, monitoring, and infrastructure MCP servers directly from the Bolt development environment. This allows AI-driven full-stack apps to interact with production infrastructure during development. [Bolt ↗]

Warp launches Oz orchestration platform

Warp introduces Oz, an AI orchestration platform built on top of the Warp terminal. Oz enables multi-step workflows defined in YAML that chain terminal commands, AI prompts, and tool invocations. Workflows can be triggered from the command palette or via the warp oz run CLI. [Warp Blog ↗]

Devin 2.0 launches with multi-agent orchestration

Cognition releases Devin 2.0 with a fundamentally rebuilt architecture featuring multi-agent orchestration. Devin now spawns specialized sub-agents for planning, coding, testing, and review. The new version also supports persistent workspaces that survive across sessions and branch-based isolation for parallel task execution. [Devin Blog ↗]

OpenCode adds experimental workspace isolation

OpenCode introduces experimental workspace support, allowing multiple isolated agent sessions to run in parallel on different branches or directories. Each workspace maintains its own conversation history, file context, and MCP server connections. Enable with experimental.workspaces: true in opencode.json. [GitHub ↗]

Cline SDK API for programmatic agent control

Cline v3.67.1 introduced the Cline SDK, a TypeScript API for programmatically controlling Cline agents. The SDK enables headless execution, CI/CD integration, and building custom workflows on top of Cline capabilities. [GitHub Releases ↗]

Custom agents via .amazonq/cli-agents/*.json

Amazon Q introduced custom agent definitions through .amazonq/cli-agents/*.json files. Each JSON file declares a specialized agent with tool access permissions, system instructions, and knowledge source references. Custom agents are invokable from the Q CLI and IDE extension. [AWS Docs ↗]

MCP support wave: Tabnine, Firebase Studio, JetBrains, Bolt

A wave of tools added MCP (Model Context Protocol) support in early 2026. Tabnine integrated MCP for enterprise tool servers, Firebase Studio added MCP for cloud service integration, JetBrains AI / Junie shipped native MCP client support, and Bolt added MCP for deployment pipelines.

Trae adds project-level MCP server configuration

Trae now supports defining MCP servers at the project level via .trae/mcp.json, complementing the existing global MCP configuration. Project-level servers are automatically started when the workspace opens and can be shared with teammates through version control. [Trae Docs ↗]

Enterprise MDM rules for managed deployments

Windsurf added Mobile Device Management (MDM) support for enterprise customers, allowing IT administrators to push default rules, approved MCP servers, and model restrictions via managed configuration profiles. Enterprise rules take precedence over user and project settings. [Windsurf Docs ↗]

Replit Agent 3 with MCP connectors and RulesSync

Replit launches Agent 3, featuring native MCP connectors for database, API, and file system tools. RulesSync is a new feature that synchronizes .replit/rules/ across team repls, ensuring consistent agent behavior. Agent 3 also supports multi-file editing with automatic dependency resolution. [Replit Blog ↗]

Tabnine adds MCP support for enterprise tool servers

Tabnine shipped MCP client support, enabling enterprise customers to connect to internal MCP tool servers for database queries, API access, and proprietary tooling. MCP servers are declared in the Tabnine workspace configuration. [Tabnine Docs ↗]

Firebase Studio launches Autonomous Agent mode

Firebase Studio introduces an autonomous agent mode that can independently plan and execute multi-step development tasks within the cloud workspace. The agent reads .idx/dev.nix for environment context, supports MCP tools, and creates checkpointed snapshots before each major change for easy rollback. [Firebase Blog ↗]

New hook events: StopFailure, Elicitation, PostCompact

Claude Code expanded its hook system with three new event types: StopFailure (fires when the agent stops due to an error), Elicitation (fires when MCP servers request user input), and PostCompact (fires after context window compaction). These enable more granular automation around error recovery and context management. [Anthropic Docs ↗]

Cursor CLI launched for terminal-based workflows

Cursor shipped a standalone CLI tool, enabling terminal-based access to Cursor agent capabilities without the full IDE. The CLI reads .cursor/rules/*.mdc files and supports the same configuration system as the desktop app. [Cursor Docs ↗]

Custom agents via .github/agents/*.agent.md

GitHub Copilot introduced custom agent definitions through .github/agents/*.agent.md files. Each file defines a specialized agent with its own system prompt, tool access, and capabilities. Agents are invokable via @agent-name in Copilot Chat. [GitHub Docs ↗]

Cline CLI 2.0 with gRPC communication layer

Cline CLI 2.0 shipped with a gRPC-based communication layer replacing the previous WebSocket approach. This enables faster, more reliable connections between the CLI and VS Code extension, plus support for remote development environments. [GitHub Releases ↗]

.amazonq/default.json replaces mcp.json for configuration

Amazon Q Developer consolidated its configuration into .amazonq/default.json, replacing the previous mcp.json file. The new format merges MCP server declarations with project settings, context rules, and tool preferences into a single unified config file. [AWS Docs ↗]

Move your mcp.json MCP server declarations into the mcpServers section of .amazonq/default.json. Other project settings can now be co-located in the same file.

JetBrains Junie ships native MCP client support

JetBrains Junie added native MCP client support, allowing developers to connect to MCP tool servers from any JetBrains IDE. MCP server configuration is managed through .junie/mcp.json at the project level or globally in the JetBrains settings directory. [JetBrains ↗]

AGENTS.md adoption reaches critical mass with 6+ tools

By January 2026, AGENTS.md had been adopted by GitHub Copilot, Windsurf, Roo Code, Warp, Kiro, and Amazon Q Developer. The file format solidified around hierarchical directory-scoped instructions with tool-agnostic markdown content.

Tabnine adds MCP Governance for enterprise admin control

Tabnine enterprise admins can now govern which MCP servers are available to developers through the admin dashboard. Governance policies support allow/deny lists per team, audit logging of MCP tool invocations, and mandatory approval workflows for new server additions. [Tabnine Enterprise Docs ↗]

Bolt V2 launches with cloud deployment and team collaboration

StackBlitz releases Bolt V2, adding cloud deployment directly from the AI builder and real-time team collaboration on generated projects. V2 also introduces a plugin system for extending the AI builder with custom component libraries and deployment targets. [Bolt Blog ↗]

Agent Skills for Cascade with .agents/skills/ directory

Windsurf launched Agent Skills, a modular system for extending Cascade with reusable capabilities. Skills are defined as markdown files in .agents/skills/ and can declare tool dependencies, input schemas, and multi-step workflows. [Windsurf Docs ↗]

settings.json massive expansion: hooks, skills, context, policy

Gemini CLI v0.30-0.33 dramatically expanded settings.json with new top-level sections for hooks (lifecycle automation), skills (reusable agent capabilities), context (file inclusion rules), and policy (security constraints). This transformed settings.json from a simple preferences file into a comprehensive agent configuration surface. [GitHub Releases ↗]

Junie integrated into JetBrains AI Chat panel

Junie is now accessible directly from the AI Chat panel in IntelliJ IDEA, PyCharm, WebStorm and other JetBrains IDEs. Users can switch between conversational AI assistance and Junie autonomous agent mode without leaving the chat interface. Junie tasks appear as expandable nodes in the chat history. [JetBrains Blog ↗]

AgentConfigLoader introduces file-based configuration

Cline v3.67.0 introduced the AgentConfigLoader system, enabling file-based configuration via .cline/config.json and .clinerules files. This moved Cline from a purely UI-driven settings model to one that supports version-controlled, shareable project configurations. [GitHub Releases ↗]

Amp launches Skills system for reusable agent capabilities

Amp introduces Skills, a system for defining reusable agent capabilities as Markdown files in .amp/skills/. Each skill file specifies a trigger pattern, instructions, and optional tool permissions. Skills can be shared across teams via Amp Hub and version-controlled alongside project code. [Amp Docs ↗]

modelOverrides setting added to settings.json

Claude Code added the modelOverrides configuration key, allowing users to specify different models for different tasks (e.g., a faster model for simple edits, a more capable model for complex reasoning). Configurable per-project or globally in ~/.claude/settings.json. [Anthropic Docs ↗]

Tabnine adds MCP server support via .tabnine/mcp_servers.json

Tabnine now supports connecting to MCP servers through a project-level .tabnine/mcp_servers.json configuration file. Server definitions follow the standard MCP transport schema with stdio and SSE support. Admins can manage allowed servers through the Tabnine dashboard. [Tabnine Docs ↗]

Goose v1.27.2 adds AGENT=goose environment variable

Goose v1.27.2 sets the AGENT=goose environment variable in all spawned processes, allowing scripts and tools to detect when they are running under Goose orchestration. This follows the emerging convention used by Claude Code (AGENT=claude-code) and others. [GitHub Release ↗]

Lovable 2.0 launches with Workspace Knowledge

Lovable 2.0 introduces Workspace Knowledge, a persistent context system that learns from project interactions and stores architectural decisions, component patterns, and user preferences. Knowledge persists across sessions and can be exported as Markdown for portability. [Lovable Blog ↗]

GEMINI_CLI_HOME environment variable for portable config

Gemini CLI introduced the GEMINI_CLI_HOME environment variable, allowing users to override the default config directory location. This enables portable configurations across machines and supports CI/CD environments where the home directory may not be writable. [GitHub Release ↗]

Cascade Hooks for automated workflows

Windsurf introduced Cascade Hooks, enabling automated actions triggered by Cascade events. Hooks can run shell commands, validate outputs, or chain agent actions based on configurable triggers defined in workspace settings. [Windsurf Docs ↗]

Augment adds SKILL.md discovery for agent capabilities

Augment Code now discovers SKILL.md files in project directories to understand available agent skills and workflows. Each SKILL.md defines a capability with trigger conditions, step-by-step instructions, and required tool access. Skills are surfaced in the Augment command palette.

Gemini CLI v0.29.0 — Gemini 3 default model

Gemini CLI v0.29.0 switched the default model to Gemini 3, bringing significant improvements in code understanding and generation quality. Users on older model configurations were prompted to upgrade. [GitHub Release ↗]

allowRead sandbox setting added

Claude Code introduced the allowRead sandbox permission, giving users fine-grained control over which files and directories the agent can read. This complements the existing allowWrite and allowExecute permissions for defense-in-depth file access control. [Anthropic Docs ↗]

Aider v0.86 adds reasoning_effort support for GPT-5

Aider v0.86 introduces the --reasoning-effort flag, allowing users to control how much compute reasoning models like GPT-5 spend on a task. Also adds the editor-diff edit format, a hybrid approach that uses an editor model to apply changes from a reasoning model draft. [Aider Changelog ↗]

Continue adds shell mode and shareable agent links

Continue introduces shell mode, allowing the agent to execute terminal commands directly from the chat interface with user approval. Additionally, agent configurations can now be shared via links, enabling teams to distribute pre-configured Continue setups with custom models, tools, and system prompts. [Continue Changelog ↗]

Windsurf adds AGENTS.md support

Windsurf Cascade began reading AGENTS.md files alongside .windsurfrules for agent-level instructions. This allows teams to maintain a single AGENTS.md that works across Copilot, Windsurf, and other supporting tools. [Windsurf Docs ↗]

Jules Tools CLI released for local task orchestration

Google releases the Jules Tools CLI, enabling developers to trigger Jules tasks from the terminal and CI pipelines. Commands include `jules run`, `jules plan`, and `jules review`. Integrates with GitHub Actions for automated PR workflows. [GitHub ↗]

Junie adds .junie/mcp/mcp.json for MCP server configuration

JetBrains Junie agent introduces project-level MCP server configuration via .junie/mcp/mcp.json. The file defines MCP servers that Junie can invoke during autonomous task execution. Supports stdio transport with command, args, and env fields. [JetBrains Docs ↗]

PearAI development cadence slows significantly

PearAI commit frequency drops to near-zero as the small team pivots focus. The VS Code fork remains functional but has fallen behind upstream changes. Community contributors maintain basic compatibility patches but no new features are being developed.

MCP elicitation support and OAuth authentication

Claude Code added support for MCP elicitation, allowing MCP servers to request additional information from users during tool execution. OAuth support was also added for MCP server authentication, enabling secure connections to third-party services without manual token management. [Anthropic Docs ↗]

Roo Code adds AGENTS.md and .roo/rules/ directory support

Roo Code added support for both AGENTS.md files and its own .roo/rules/ directory structure. The .roo/rules/ system supports mode-specific rules (e.g., code.md, architect.md) that activate based on the current Roo Code operating mode. [GitHub Releases ↗]

Jules shifts from free preview to freemium pricing

Google Jules transitions from unlimited free preview to a freemium model. Free tier includes 10 tasks per day with standard models. Pro tier ($20/month) adds unlimited tasks, priority queue, and access to Gemini 2.5 Pro for complex multi-file changes. [Jules Pricing ↗]

Copilot adds AGENTS.md support

GitHub Copilot began reading AGENTS.md files for agent-mode instructions, joining the emerging cross-tool standard. AGENTS.md files at any directory level are merged into the agent context, complementing copilot-instructions.md. [GitHub Blog ↗]

AGENTS.md emerges as cross-tool agent instruction standard

AGENTS.md gained adoption across multiple tools throughout 2025, becoming a de facto standard for agent-level instructions. Copilot, Windsurf, Roo Code, Warp, and Kiro all added support, allowing teams to write agent instructions once and have them read by any supporting tool.

Aider v0.82 introduces patch edit format

Aider v0.82 adds the "patch" edit format, a unified-diff-style approach that significantly reduces token usage for large file edits. The new format is automatically selected when working with models that support structured output. Legacy whole-file and diff formats remain available via --edit-format flag. [Aider Changelog ↗]

Firebase Studio (Project IDX) adds MCP support via .idx/mcp.json

Firebase Studio introduces MCP server configuration through .idx/mcp.json. The file specifies MCP servers available in the cloud workspace, with support for stdio transport and environment variable injection. Servers are automatically started when the workspace boots. [Firebase Studio Docs ↗]

Amazon Q adds .amazonq/rules/ for project-level instructions

Amazon Q Developer introduced the .amazonq/rules/ directory for project-level coding instructions, following the trend of directory-based rule systems. Rules files use markdown format and support glob-based scoping similar to Cursor MDC files. [AWS Docs ↗]

Void v1.4.1 final release adds MCP support

The final Void release (v1.4.1) adds Model Context Protocol support before the development pause. MCP servers can be configured in void.config.json under the mcpServers key. This was the last feature shipped before the project went on hiatus.

Jules adds AGENTS.md support for project context

Google Jules now reads AGENTS.md files from the repository root to understand project conventions, architecture decisions, and coding standards. The file follows the emerging AGENTS.md community standard and is included as system context when Jules plans and executes tasks. [Jules Docs ↗]

Void development paused, community forks emerge

The Void editor project announces an indefinite development pause citing funding challenges. The open-source codebase remains available and several community forks have appeared. Users are advised to export their configurations as the hosted sync service will shut down.

copilot-instructions.md moves to .github/ directory

GitHub Copilot standardized the location of project-level instructions from copilot-instructions.md in the repo root to .github/copilot-instructions.md. The root-level file is still read as a fallback but the .github/ location is now canonical. [GitHub Docs ↗]

Aider adds .aider.model.settings.yml for model profiles

Aider introduced .aider.model.settings.yml, enabling users to define custom model profiles with parameters like temperature, token limits, and reasoning settings. Model settings files are read from both the project root and ~/.aider/ for global defaults. [Aider Docs ↗]

.cursorrules deprecated in favor of .cursor/rules/*.mdc

Cursor deprecated the flat .cursorrules file in favor of a structured .cursor/rules/ directory containing .mdc (Markdown Component) files. Each .mdc file can specify globs, descriptions, and scoped instructions, replacing the monolithic single-file approach. [Cursor Docs ↗]

Move your .cursorrules content into .cursor/rules/project.mdc. Add frontmatter with description and globs fields. Split large rule sets into multiple .mdc files for better scoping.