Shojaeei/project-continuity

Project Continuity Skill

Core Principle

NEVER create a new project when an existing one should be improved.

When asked to fix, update, improve, or enhance something, the LLM MUST:

1. Work on the EXISTING project
2. Use version control (git)
3. Modify existing files, not create duplicates

Mandatory Pre-Work Checklist

Before ANY code change, ALWAYS:

1. Project Detection

✅ CHECK: Is this an existing project?
   - Look for: .git, pyproject.toml, package.json, requirements.txt, Cargo.toml
   - If found → This is EXISTING project
   - If not found → ASK user before creating new

✅ CHECK: What is the project root?
   - Run: git rev-parse --show-toplevel
   - Work within this directory

2. Existing File Discovery

✅ BEFORE creating any file:
   - Search for similar/existing files: Glob, Grep
   - Check if functionality already exists
   - Prefer modifying existing files over creating new ones

✅ Pattern to follow:
   1. Search → 2. Read → 3. Modify (or create if truly new)

3. Version Control Protocol

✅ Before starting work:
   - git status (check current state)
   - git log --oneline -5 (understand recent changes)

✅ During work:
   - Make incremental commits
   - Use descriptive commit messages
   - Reference issue numbers if applicable

✅ After completing:
   - git add <specific-files>
   - git commit with proper message
   - git push (if requested)

Forbidden Actions

❌ NEVER Do These:

1. Create duplicate projects

   • If project exists in /home/user/myproject, don't create /home/user/myproject-new

2. Create parallel implementations

   • If auth.py exists, don't create auth_new.py
   • Modify auth.py instead

3. Start from scratch without asking

   • "I'll create a fresh project" → WRONG
   • "Let me check the existing structure first" → CORRECT

4. Ignore existing code

   • Read existing files before adding new ones
   • Understand the current architecture

5. Skip git for "small changes"

   • Every change should be tracked
   • Use branches for larger features

Correct Approach

When Asked to "Fix X":

1. Understand: User wants existing X fixed
2. Search: Find where X is implemented
3. Read: Understand the existing implementation
4. Modify: Fix X in its current location
5. Test: Verify the fix works
6. Commit: git commit with descriptive message

When Asked to "Add Feature Y":

1. Check: Does Y already exist?
2. If exists: Enhance it in place
3. If not:
   a. Find the appropriate module
   b. Check existing patterns
   c. Add Y following those patterns
   d. Update related files

When Asked to "Improve Z":

1. Analyze: What is Z currently?
2. Identify: Where can improvements be made?
3. Refactor: Improve Z in place
4. Maintain: Backward compatibility where possible
5. Document: Update comments/docs

Git Branch Strategy

For significant changes:

# Create feature branch
git checkout -b feature/description

# Work on changes
# ... make modifications ...

# Commit incrementally
git add <files>
git commit -m "descriptive message"

# When ready to merge
git checkout main
git merge feature/description

# Clean up
git branch -d feature/description

File Modification Priority

When implementing changes:

| Priority | Action | When to Use | |----------|--------|-------------| | 1 | Modify existing file | Same functionality location | | 2 | Extend existing module | Adding to existing feature | | 3 | Create new file in existing module | New but related functionality | | 4 | Create new module | New major feature area |

Examples

❌ WRONG (Creating New):

User: "Fix the authentication bug"
LLM: "I'll create a new auth system in auth_v2.py"
Result: Two auth systems, confusion, technical debt

✅ CORRECT (Fixing Existing):

User: "Fix the authentication bug"
LLM:
  1. Searches for auth-related files
  2. Finds auth.py with the bug
  3. Reads and understands the code
  4. Fixes the specific bug
  5. git commit -m "fix: resolve auth token expiration issue"

❌ WRONG (Ignoring Version):

User: "Update the API to use new format"
LLM: Makes changes, no git operations
Result: No history, can't revert, can't track changes

✅ CORRECT (Using Git):

User: "Update the API to use new format"
LLM:
  1. git checkout -b feature/api-format-update
  2. Modifies api.py
  3. Updates tests
  4. git add api.py tests/
  5. git commit -m "feat: update API to use new format"
  6. git checkout main && git merge feature/api-format-update

Self-Check Before Every Response

Before writing code, ask yourself:

1. ☐ Did I check if this file/module already exists?
2. ☐ Am I modifying the existing implementation?
3. ☐ Did I read the current code before changing?
4. ☐ Will I commit these changes with git?
5. ☐ Am I working within the project root?

If any answer is NO → STOP and correct approach.

Enforcement

This skill is ALWAYS ACTIVE for any code modification request:

• Fixes
• Updates
• Improvements
• Enhancements
• Refactors
• Bug fixes
• Feature additions

The default behavior is: MODIFY EXISTING, DON'T CREATE NEW.