playbooks

home / skills / jeremylongshore / claude-code-plugins-plus-skills / cursor-advanced-composer

cursor-advanced-composer skill

/plugins/saas-packs/cursor-pack/skills/cursor-advanced-composer

This skill helps you manage advanced Cursor Composer workflows for multi-file edits, coordinating features, patterns, and tests across large codebases.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill cursor-advanced-composer

Review the files below or copy the command above to add this skill to your agents.

Files (8)
SKILL.md
1.8 KB
---
name: "cursor-advanced-composer"
description: |
  Manage advanced Cursor Composer techniques for complex edits. Triggers on "advanced composer",
  "composer patterns", "multi-file generation", "composer refactoring". Use when working with cursor advanced composer functionality. Trigger with phrases like "cursor advanced composer", "cursor composer", "cursor".
allowed-tools: "Read, Write, Edit, Bash(cmd:*)"
version: 1.0.0
license: MIT
author: "Jeremy Longshore <[email protected]>"
---

# Cursor Advanced Composer

## Overview

This skill covers advanced Cursor Composer techniques for complex multi-file edits. It provides patterns for coordinated file creation, architecture migrations, pattern replication, and quality control workflows for large-scale code generation.

## Prerequisites

- Cursor IDE with Composer feature access
- Understanding of project structure and patterns
- Well-configured .cursorrules file
- Indexed codebase for @-mention references

## Instructions

1. Open Composer with Cmd+I (Mac) or Ctrl+I (Windows)
2. Describe the feature or changes needed
3. Reference existing patterns with @-mentions
4. Specify file structure and naming conventions
5. Review each proposed change before applying
6. Apply changes incrementally, testing between phases

## Output

- Multiple coordinated file changes
- Generated feature modules with consistent patterns
- Refactored codebase following specified patterns
- Complete test coverage for generated code

## Error Handling

See `{baseDir}/references/errors.md` for comprehensive error handling.

## Examples

See `{baseDir}/references/examples.md` for detailed examples.

## Resources

- [Cursor Composer Documentation](https://cursor.com/docs/composer)
- [Multi-File Editing Best Practices](https://cursor.com/docs/best-practices)
- [Cursor Community Tips](https://forum.cursor.com/)

Overview

This skill manages advanced Cursor Composer techniques for orchestrating complex, multi-file edits and refactors. It provides patterns and workflows to create coordinated feature modules, migrate architectures, and enforce consistent coding patterns across a codebase. Use it to automate large-scale changes while preserving code quality and test coverage.

How this skill works

The skill inspects Composer inputs and project structure, then generates a step-by-step plan for coordinated file creation and updates. It references indexed code patterns via @-mentions, produces code templates for each target file, and stages changes for incremental review and application. Built-in checks recommend tests and sanity checks before committing edits.

When to use it

  • Creating multi-file features or modules in one session
  • Refactoring or migrating architecture patterns across many files
  • Replicating consistent patterns or templates throughout a codebase
  • Enforcing naming conventions and project structure during generation
  • When you need staged, reviewable edits with automated test suggestions

Best practices

  • Index your codebase and set up a .cursorrules file before large operations
  • Reference existing patterns by @-mentioning canonical implementations
  • Describe desired file structure and naming conventions explicitly up front
  • Apply changes incrementally and run tests between phases
  • Review proposed edits carefully before committing to avoid broad regressions

Example use cases

  • Generate a new feature module spanning API, service, and UI layers with matching tests
  • Migrate repository from legacy patterns to a new architecture across dozens of files
  • Replicate a vetted design pattern into multiple packages with correct imports and configs
  • Bulk rename and reorganize packages while preserving references and updating tests
  • Create coordinated CRUD endpoints, data models, and client SDKs in one workflow

FAQ

How do I reference existing patterns so Composer reuses them?

Mention canonical implementations using @-mentions after indexing your codebase; Composer will locate and adapt those patterns for the new files.

What safety measures prevent breaking the repository?

Use incremental application: Composer stages changes for review, suggests tests to run between phases, and follows .cursorrules constraints to limit scope.