# Cursor Features and Practical Usage 🧩 Tired of re-explaining the same multi-step workflow to your agent every single time? Cursor Skills let you package repeatable workflows so the agent just knows how to do them. 🏷️ Title: Reusable Workflows (SKILL.md) 🔗 URL: 📘 Overview Skills are portable, version-controlled packages that teach agents how to perform domain-specific tasks. They bundle scripts, templates, and reference material that the agent runs through its available tools. They are the evolution of Rules: agents can apply them automatically based on context, or you can invoke them explicitly as slash commands. ⚙️ How It Works Each skill is centered on a `SKILL.md` file whose leading YAML frontmatter defines its behavior. ・`name`: a lowercase identifier that must match the parent folder name (required) ・`description`: what the skill is for and when it applies; the agent reads this to decide whether to use it (required) ・`paths`: glob patterns that scope the skill to matching files (optional) ・`disable-model-invocation`: set to `true` to make it slash-only, included only when you type `/skill-name` (optional) Discovery is hierarchical: project skills live in `.cursor/skills/` (or `.agents/skills/`), and global ones in `~/.cursor/skills/`. The root is walked recursively, so nested subdirectories are found too. A skill folder can also ship `scripts/` (executable code), `references/` (docs loaded on demand), and `assets/` (templates or images). 🛠️ Practical Usage For example, in `.cursor/skills/api-endpoint/SKILL.md` set the frontmatter `name` to `api-endpoint`, a `description` of the workflow, and `paths` scoped to `src/api/**/*.ts`, then write the steps in the body (register the route, validate input with a zod schema, always add tests). If you do not want automatic invocation, add `disable-model-invocation: true` and call it explicitly by typing `/api-endpoint` in Agent chat. 💡 Use Cases In a monorepo, placing a `.cursor/skills/` folder inside each app automatically scopes those skills to files in that directory, so you can skip `paths` entirely. Share release procedures, migration scripts, or code-review checklists so the whole team works the same way. You can convert existing assets with the built-in `/migrate-to-skills` (Cursor 2.4): "Apply Intelligently" rules (`alwaysApply: false`) become skills, and slash commands become skills with `disable-model-invocation: true`. ⚠️ Caveats A skill's identity comes from the folder containing `SKILL.md`, not any parent category. The old `globs` field is deprecated; use `paths` now. `/migrate-to-skills` does not migrate `alwaysApply: true` rules or user-level rules, so those need manual handling. #Cursor# #AICoding#

# Cursor Features and Practical Usage 📏 "Always validate APIs with zod" — you shouldn't have to retype that policy every prompt. Cursor's Rules give the AI persistent memory. 🏷️ Title: Persistent Instructions (Project/Team/AGENTS.md) 🔗 URL: 📘 Overview Rules provide persistent, system-level instructions to Cursor's Agent. Since LLMs don't retain memory between completions, Rules supply reusable context at the prompt level. They bundle prompts, scripts, and guidance so workflows stay reusable across a team. ⚙️ How It Works Cursor supports several kinds of Rules. ・Project Rules: `.mdc` files under `.cursor/rules`, version-controlled and scoped to your codebase. ・User Rules: global preferences defined in Cursor Settings, applied across all projects. ・Team Rules: org-wide rules managed from the dashboard (Team/Enterprise plans). ・AGENTS.md: a plain-markdown alternative in the project root or subdirectories, no frontmatter needed and nestable (more specific instructions take precedence over parent ones). Project Rule frontmatter controls behavior: `alwaysApply: true` applies to every chat, `globs` with `alwaysApply: false` auto-attaches when matching files are in context, `description` only lets the Agent apply it when relevant, and with none of these it applies only via `@`-mention. 🛠️ Practical Usage ・Scope rules to file types with globs, e.g. `src/**/*.tsx`, comma-separating multiple patterns. This auto-applies "always validate APIs with zod" whenever matching files are edited. ・Generate rules in chat with `/create-rule`, or via `Cursor Settings > Rules, Commands` → "+ Add Rule." ・Example `.mdc`: a frontmatter with `globs: src/api/**/*.ts` and `alwaysApply: false`, followed by rules like "validate every incoming payload with a zod schema" and "on failure, return 400 with a unified error shape." ・For teams, remember the application order Team Rules → Project Rules → User Rules, and enforce company-wide conventions via Team Rules. 💡 Use Cases Turn repeated policies — "validate APIs with zod," "use Conventional Commits," "structured JSON logging" — into Rules, auto-applied only to matching files via globs. Check them into Git so the whole team benefits from the same conventions. ⚠️ Caveats Keep each rule under 500 lines and split larger ones. Avoid copying style guides (use linters), and prefer referencing files over duplicating content. Target frequent patterns, not rare edge cases. Note that User Rules apply only to Agent (Chat) — not to Inline Edit, other AI features, or Cursor Tab. #Cursor# #AICoding#

Cursor team will be visiting these cities over the next few weeks: • Nairobi • Bangkok • Da Nang • Tokyo • Sapporo • Accra • Bali • Kathmandu • Delhi • Bangalore • Casablanca • Mumbai • Hyderabad Sign up on Luma (limited spots)

# Cursor Features and Practical Usage ✏️ No chat needed — select code and say "make this async" right where it lives. Cursor's Inline Edit is the shortest path to local fixes. 🏷️ Title: Cmd/Ctrl+K 🔗 URL: 📘 Overview Inline Edit lets you make focused code changes directly in the editor without opening the chat. Select code and press `Cmd+K` (Mac) / `Ctrl+K` (Windows/Linux), and an instruction box opens in place. It's built for fast, pinpoint edits. ⚙️ How It Works ・Give a natural-language instruction on the selected code and press `Return` to apply, e.g. "Convert this to an async function." ・It supports iterative refinement — request follow-up edits and they apply sequentially. ・Question mode: press `Opt+Return` (Mac) / `Alt+Return` (Windows/Linux) to ask about the selected code instead of editing it. If you want to implement a suggestion, type "do it" and confirm. ・Escalate to Agent: for larger, multi-file changes, select code and press `Cmd+L` (Mac) / `Ctrl+L` (Windows/Linux) to open Agent with your selection as context. 🛠️ Practical Usage ・Select a function and `Cmd+K` → "make it async," "add type annotations," "turn this branch into an early return" — cycle through local rewrites fast. ・When behavior is unclear, switch to question mode with `Opt+Return`, ask "what does this regex match?", then type "do it" to move to a fix if needed. ・When a fix grows complex and spreads across files, hand the selection to Agent with `Cmd+L` and escalate to autonomous implementation. 💡 Use Cases Quickly fix a single function flagged in review with `Cmd+K`, verify shaky logic in question mode before changing it, and promote to Agent once impact widens — a staged workflow that fits the size of the change. ⚠️ Caveats Inline Edit is meant for local, focused edits. Rather than forcing broad changes through `Cmd+K`, hand off to Agent with `Cmd+L` early for safer, more reliable results. Also note that User Rules generally apply only to Agent (Chat), not to Inline Edit. #Cursor# #AICoding#

Cursor is now on iPhone This is much more than a companion app You can now build software from anywhere by launching always-on cloud agents directly from your phone, or remotely control agents already running on your computer The app lets you: • Launch cloud agents from iPhone • Monitor active agent tasks in real time • Review completed work • Remotely control agents running on your Mac or PC • Continue coding workflows without being at your desk Instead of waiting until you’re back at your computer, you can kick off long-running development tasks from anywhere and let Cursor’s cloud agents do the work in parallel Cursor also announced that Composer 2.5 is 75% off in the iOS app through July 5, making it easier to try their latest coding model This is a major shift in how software gets built. Your computer is no longer the only place where coding happens It’s becoming the place where you supervise AI agents that are building software for you.....whether you’re at your desk or halfway across the world

# Cursor Features and Practical Usage 🧭 Code now, plan first, or just investigate? Cursor lets you switch the agent's behavior with a single `Shift+Tab`. 🏷️ Title: Agent Modes (Shift+Tab) 🔗 URL: 📘 Overview Cursor's agent has multiple modes so its behavior matches the task at hand. Press `Shift+Tab` in the chat input to rotate through modes, or pick one from the mode dropdown. When Cursor detects complex work, it may automatically suggest Plan mode. ⚙️ How It Works ・Agent mode: the standard implementation mode. Best for quick changes or familiar tasks where jumping straight into code makes sense. ・Plan mode: builds a plan before coding. The agent asks clarifying questions to understand requirements, researches your codebase to gather context, and generates a comprehensive plan for review. The workflow is: Questions → Research → Plan Creation → Review/Edit → Build. ・The plan is editable in chat or as markdown, and you proceed to build only once satisfied. Plans save to your home directory by default, but you can move them into the workspace for team collaboration. 🛠️ Practical Usage ・For features that ripple across many files, generate a plan in Plan mode, approve it, then implement — this minimizes rework. ・When you only want to investigate, use a read-only style mode and ask "How does this auth flow work?" to understand the current state without edits. ・For debugging, paste the stack trace or logs and walk through hypothesis generation → root-cause identification → fix strategy for steadier diagnosis. ・Use `Shift+Tab` to cycle modes quickly and match the granularity of the task. 💡 Use Cases Approve the big picture in Plan mode before a large refactor, investigate safely in a read-only mode, and pin down bugs from a pasted error to root cause. Splitting work into phases keeps the scope you delegate to the AI under control. ⚠️ Caveats The docs stress a key principle: when the agent's output misses the mark, reverting the changes and refining the plan is often faster than chasing fixes with follow-up prompts. Figuring out what to change is the hard part — delegate the implementation to Agent. #Cursor# #AICoding#

# Cursor Features and Practical Usage 🤖 Just say "replace auth with JWT" and Cursor's Agent searches, edits across files, and runs your tests in one autonomous flow. 🏷️ Title: Autonomous Agent (Cmd+I) 🔗 URL: 📘 Overview Agent is Cursor's AI assistant, opened in the sidepane with `Cmd+I`. It orchestrates three components — instructions (prompts/rules), tools, and your chosen model — to work autonomously across your codebase. Cursor tunes the tool usage specifically for each frontier model it supports. ⚙️ How It Works Agent calls a rich set of tools to complete tasks, with no limit on the number of tool calls per task. ・Semantic search over your indexed codebase to find code by meaning ・File read/write, directory traversal, and keyword/pattern search ・Terminal command execution with output monitoring ・Web search, image reading (png/jpg/gif/webp/svg), and UI mockup image generation ・Browser control for screenshots and visual verification of changes ・Clarifying questions to the user while continuing work in the background 🛠️ Practical Usage ・Open Agent with `Cmd+I` and describe your goal in plain language, e.g. "Migrate auth from sessions to JWT and make the related tests pass." ・Queue follow-ups while it works: `Enter` adds a message to the queue (runs after the current task), while `Cmd+Enter` sends immediately, bypassing the queue. Drag queued messages to reorder them. ・Checkpoints are auto-saved before major changes. Click any checkpoint in the chat timeline to preview that state, then "Restore Checkpoint" to revert all modified files. ・Set your terminal profile via `Cmd/Ctrl+Shift+P` → "Terminal: Select Default Profile". 💡 Use Cases The classic flow: ask "replace auth with JWT," and Agent locates the implementation via search, edits multiple files, then runs the test suite to confirm. Queue "also add structured logging" mid-run, and it continues with that once the current task finishes. ⚠️ Caveats Checkpoints are stored locally and are separate from Git. Use them only for undoing Agent changes — rely on Git for permanent version control. Since tool calls are unlimited, keep a human eye on destructive terminal operations. #Cursor# #AICoding#

Cursor is hiring design engineers. looking for people with taste, systems thinking, and deep care for fast, polished experiences – especially folks excited to build the tools that help designers, engineers, and agents ship quality code. know someone? tag them or DM me 📧