principle-redesign-from-first-principles
cursor/plugins
Redesign existing systems as if new requirements were foundational, not bolted-on.
What is principle-redesign-from-first-principles?
A design methodology for integrating new requirements into existing code by rethinking the entire architecture from scratch rather than patching. Use this when a change is significant enough to warrant reconsidering foundational assumptions.
- Read and understand all affected files and current design patterns
- Reimagine the system as if the new requirement had been a day-one assumption
- Propagate changes consistently through types, documentation, examples, and rationale
- Plan the complete redesign before implementing incrementally
- Preserve architectural option value when integrating major changes
How to install principle-redesign-from-first-principles
npx skills add https://github.com/cursor/plugins --skill principle-redesign-from-first-principlesHow to use principle-redesign-from-first-principles
- 1.Read and map all files affected by the new requirement
- 2.Write out the question: 'If we built this from scratch with this requirement, what would we design?'
- 3.Sketch the ideal architecture without legacy constraints
- 4.Identify all touchpoints: types, interfaces, documentation, examples
- 5.Plan incremental rollout of the redesign
- 6.Implement changes systematically across all affected areas
Use cases
- Adding a new core constraint (e.g., multi-tenancy, offline-first) to a single-tenant system
- Integrating a significant new feature that touches multiple subsystems
- Refactoring when a new requirement reveals fundamental design misalignment
- Redesigning APIs or data models when new use cases emerge
- Updating architecture when performance or security requirements change
- Software architects
- Senior engineers redesigning systems
- Teams integrating major new requirements
- Code reviewers evaluating large structural changes
principle-redesign-from-first-principles FAQ
Use this when the requirement is foundational (affects core behavior, data model, or API contract) rather than peripheral. Quick patches work for edge cases; first-principles redesign works for changes that reshape the system.
The goal is not perfection but coherence. Ask whether the new requirement would have changed your initial design decisions. If yes, redesign; if no, a patch may suffice.
Yes. Plan the full redesign first, then roll it out in phases, ensuring each phase is internally consistent and doesn't leave the codebase in a broken state.
Break it into smaller redesigns, each addressing a specific subsystem or layer. Ensure each phase maintains coherence and doesn't create technical debt.
Full instructions (SKILL.md)
Source of truth, from cursor/plugins.
name: principle-redesign-from-first-principles description: "Apply when integrating a new requirement into an existing design. Redesign as if the requirement had been a foundational assumption from day one, instead of bolting it on." disable-model-invocation: true
Redesign From First Principles
When integrating a change, don't bolt it onto the existing design. Redesign as if the requirement had been there from the start.
- Read all affected files and understand the current design
- Ask: "if we were writing this from scratch with this new requirement, what would we build?"
- Propagate the change through every reference: types, docs, examples, rationale sections
- Think about the whole redesign, then deliver it incrementally
This is the method for preserving option value when integrating changes into an existing design.
Related skills
More from cursor/plugins and the wider catalog.
principle-separate-before-serializing-shared-state
Eliminate concurrent write conflicts by separating mutable state before applying serialization.
principle-sequence-verifiable-units
Break multi-step work into small verifiable units, sequence commits to prove the logic to reviewers.
principle-subtract-before-you-add
Remove complexity first—delete dead code and redundancy before adding features or refactoring.
principle-type-system-discipline
Apply type-system discipline to eliminate impossible states and catch bugs at compile time.
recall
Reconstruct your recent working context from chat history and shared records to resume work efficiently.
reflect
Mine conversations for durable learnings and route them into skill edits.