AI Coding Keyboard Shortcuts and Workflows

Claude Code Shortcuts and Commands

Claude Code operates in the terminal — speed comes from command patterns, not GUI shortcuts. The essential workflow: open terminal in your project root (where CLAUDE.md lives), type claude to start a session. The AI: reads your CLAUDE.md automatically and applies your conventions to every response. Key commands: /help (list all commands), /clear (reset context without losing rules), /compact (compress conversation to free context window). The /compact command: critical for long sessions where you've accumulated context — it preserves the important information while freeing space for more work.

Workflow pattern for Claude Code power users: start the session with a specific goal ('Implement the user settings page'). Let Claude Code read the relevant files. Review the generated code. Use follow-up prompts for refinements ('Use our ErrorBoundary component instead of try-catch here'). Commit when satisfied. The pattern: goal → generate → review → refine → commit. Each cycle: 5-15 minutes. Multiple cycles per feature. The session: stays focused because each cycle has a clear deliverable.

Advanced Claude Code patterns: use ! prefix to run shell commands within the session (! pnpm test to verify tests pass after code changes). Use @ to reference specific files (@src/components/Button.tsx — modify this to add a loading state). Chain operations: 'Add the API endpoint, write the tests, and run them.' Claude Code: executes the full chain, fixing failures along the way. AI rule: 'Claude Code speed comes from three practices: focused sessions (one goal per session), chained operations (multiple steps per prompt), and inline shell commands (verify without leaving the session).'

Cursor AI Shortcuts and Workflows

Cursor's keyboard shortcuts center on the AI interaction model. Cmd+K (Ctrl+K on Windows/Linux): open inline AI edit — select code, describe the change, the AI edits in place. Cmd+L: open the chat panel for longer conversations. Cmd+Shift+L: add the current file to chat context. Tab: accept AI suggestion (like Copilot). Esc: dismiss suggestion. The most productive Cursor workflow: Cmd+K for quick edits (rename, refactor, add error handling), Cmd+L for feature implementation (multi-file changes).

Cursor Composer (Cmd+Shift+I): the multi-file editing mode. Describe a feature: 'Add user authentication with login, registration, and session management.' Composer: creates or modifies multiple files simultaneously. The workflow: describe the feature → review all changes → accept or refine. Composer respects .cursorrules for convention compliance. Power user tip: use Composer for new features (multi-file creation) and Cmd+K for modifications to existing code (targeted edits). The separation: keeps each tool at its optimal scope.

Cursor context shortcuts: @file to reference a specific file in chat. @folder to include an entire directory. @codebase for project-wide search context. @web for including web search results. The context management: determines code quality. Too little context: the AI guesses conventions. Too much context: the AI is overwhelmed. The sweet spot: @file for the files you're changing + @folder for the module they belong to. AI rule: 'Cursor productivity scales with context precision. The @ reference system: tells the AI exactly what to look at. Precise context + good rules = convention-compliant code without extra prompting.'

💡 Ctrl+Enter Opens 10 Copilot Alternatives — Most Developers Never Use It

Copilot suggests a function. It is close but not quite right. Most developers: Tab to accept, then manually edit. Power users: Ctrl+Enter to open the completions panel showing 10 alternative implementations. Browse with arrow keys. Often: the correct version is suggestion #3 or #5. Time saved: 2-5 minutes of manual editing per instance. Frequency: 5-10 times per day. Daily savings: 10-50 minutes from one shortcut most Copilot users do not know exists.

GitHub Copilot Shortcuts and Workflows

Copilot's core shortcuts: Tab (accept suggestion), Esc (dismiss), Alt+] (next suggestion), Alt+[ (previous suggestion), Ctrl+Enter (open Copilot completions panel with 10 alternatives). The completions panel: underused by most developers. When the first suggestion is close but not right: Ctrl+Enter shows alternatives. Often: the correct version is in the list. Time saved: versus manually editing the first suggestion.

Copilot Chat shortcuts (VS Code): Ctrl+I (inline chat — edit selected code with a prompt). Cmd+Shift+I (Copilot Edits — multi-file editing like Cursor Composer). /fix (fix the selected code), /explain (explain the selected code), /tests (generate tests for the selected code). Slash commands: faster than typing full prompts for common operations. The /tests command: generates test files that follow your workspace instructions. The /fix command: identifies and corrects bugs in the selected code.

Copilot workspace instructions: create .github/copilot-instructions.md in your repository. This file: equivalent to CLAUDE.md for Copilot. Copilot reads it and applies the conventions to all suggestions and chat responses. Power user workflow: maintain both CLAUDE.md (for Claude Code) and .github/copilot-instructions.md (for Copilot) with synchronized conventions. RuleSync: automates this synchronization. AI rule: 'Copilot productivity comes from two underused features: the completions panel (Alt+]/[ to browse alternatives) and workspace instructions (.github/copilot-instructions.md for project-specific conventions). Most Copilot users only use Tab — unlocking the full shortcut set multiplies effectiveness.'

ℹ️ The @ Context System Is Cursor's Biggest Productivity Lever

Cursor without @ references: the AI guesses which files are relevant. Sometimes right, sometimes wrong. Cursor with precise @ references: @src/components/Button.tsx @src/styles/tokens.ts 'Add a loading state variant.' The AI: reads exactly the files it needs, understands the existing patterns, and generates code that fits. The difference: 1 prompt with correct output vs 3-4 prompts refining incorrect guesses. Time saved per feature: 5-15 minutes. The @ system: not optional for productive Cursor usage.

Cross-Tool Workflow Patterns

The multi-tool workflow: many teams use Claude Code for complex features (agentic multi-step implementation), Cursor for editor-integrated development (inline edits and chat), and Copilot for quick completions (autocomplete while typing). The workflow: start a feature in Claude Code (architecture and scaffolding), refine in Cursor (component-level edits), and use Copilot for micro-completions (filling in function bodies). Each tool: at its optimal scope.

Rule synchronization across tools: the critical practice for multi-tool teams. CLAUDE.md (Claude Code), .cursorrules (Cursor), .github/copilot-instructions.md (Copilot) — three files with identical conventions. Update one: must update all three. The manual approach: copy conventions between files after each change. The automated approach: RuleSync synchronizes rules from a single source to all tool formats. The result: consistent AI-generated code regardless of which tool generates it.

Universal workflow optimizations: regardless of tool, these patterns increase productivity. 1) Start every session by verifying the rules file is current. 2) Use the AI to generate tests before implementation. 3) Ask the AI to self-review before you review. 4) Commit in small increments (after each successful AI-generated feature). 5) Update rules when you notice repeated review comments. These five practices: tool-agnostic and universally effective. AI rule: 'The most productive AI coding workflow: is not about any single tool. It is about combining tools at their optimal scope, synchronizing rules across all tools, and following consistent practices regardless of which tool you are using at the moment.'

⚠️ Three Rule Files Must Stay Synchronized or Quality Drops

Team uses Claude Code and Cursor. CLAUDE.md says 'Use Result pattern for errors.' .cursorrules is not updated — still says 'Use try-catch.' Developer A (Claude Code): generates Result pattern code. Developer B (Cursor): generates try-catch code. Same project, same sprint, different conventions. The code review: catches the mismatch. Time wasted: the entire benefit of having rules. The fix: synchronize CLAUDE.md, .cursorrules, and copilot-instructions.md after every rule change. RuleSync: automates this. Manual sync: works but requires discipline.

Keyboard Shortcuts Quick Reference

Quick reference of essential AI coding shortcuts across tools.

Claude Code: /compact (free context), /clear (reset), ! prefix (shell commands), @ prefix (file reference)
Cursor: Cmd+K (inline edit), Cmd+L (chat), Cmd+Shift+I (Composer multi-file), Tab (accept), @file/@folder (context)
Copilot: Tab (accept), Alt+]/[ (browse suggestions), Ctrl+Enter (completions panel), Ctrl+I (inline chat)
Copilot Chat: /fix (fix code), /explain (explain), /tests (generate tests), Cmd+Shift+I (Copilot Edits)
Universal: verify rules → generate tests → implement → self-review → commit → update rules
Multi-tool: Claude Code for architecture, Cursor for component edits, Copilot for autocomplete
Rule sync: CLAUDE.md + .cursorrules + copilot-instructions.md — keep all three synchronized
Key habit: update rules immediately when you notice repeated review comments — prevents recurrence