Prompt file imported from GiantCroissant-Lunar/pigeon-pea (.windsurf/workflows/feature.md). Copyright stays with the author.

Feature Development Workflow

Name: feature
Author: GiantCroissant-Lunar

Complete workflow for developing a new feature from planning to pull request.

1. Planning Phase

Analyze Requirements

Review the feature requirements with the user if unclear
Understand the expected behavior and scope
Identify which parts of the codebase are affected

Review Existing Code

Read relevant files in the affected areas
Understand the current architecture and patterns
Identify where the feature should be integrated

Create Task Breakdown

Break down the feature into specific, implementable tasks
Identify dependencies between tasks
Estimate complexity and potential challenges

Identify Risks

Consider edge cases
Check for breaking changes
Identify integration points that might cause issues

2. Implementation Phase

Create Feature Branch

git checkout -b feature/<feature-name>

Implement Core Functionality

Write the core code following existing patterns
Ensure code quality and readability
Add appropriate error handling
Follow the project's coding standards

Write Unit Tests

Create tests for new functionality
Aim for meaningful coverage
Test edge cases and error conditions
Ensure tests are clear and maintainable

Update Documentation

Update relevant documentation in docs/
Add code comments for complex logic
Update README if public API changes

3. Quality Checks

Format Code

task dotnet:format

Run Pre-commit Hooks

pre-commit run --all-files

Fix any issues found by the hooks.

Build and Test

task game:build-console
task dotnet:test

Fix any build errors or test failures autonomously.

Run the Application

task game:run-console

Verify the feature works as expected.

Self-Review

Review all changes made
Check for code quality issues
Ensure no debugging code left behind
Verify security implications

4. Integration Phase

Merge Latest Changes

git fetch origin main
git merge origin/main

Resolve any conflicts if they arise.

Run Tests Again

task dotnet:test

Ensure integration didn't break anything.

Create Pull Request

gh pr create --title "feat: <feature-name>" --body "$(cat <<'EOF'
## Summary
- Brief description of the feature
- What problem it solves

## Changes
- List of key changes made

## Testing
- How to test the feature
- Test scenarios covered

## Checklist
- [x] Tests added/updated
- [x] Documentation updated
- [x] Pre-commit hooks pass
- [x] Application runs successfully

🤖 Generated with Windsurf
EOF
)"

5. Final Report

Provide summary:

Feature implemented: [description]
Files changed: [count]
Tests added: [count]
PR created: [URL]
Status: Ready for review

# Feature Development Workflow Complete workflow for developing a new feature from planning to pull request. ## 1. Planning Phase ### Analyze Requirements - Review the feature requirements with the user if unclear - Understand the expected behavior and scope - Identify which parts of the codebase are affected ### Review Existing Code - Read relevant files in the affected areas - Understand the current architecture and patterns - Identify where the feature should be integrated ### Create Task Breakdown - Break down the feature into specific, implementable tasks - Identify dependencies between tasks - Estimate complexity and potential challenges ### Identify Risks - Consider edge cases - Check for breaking changes - Identify integration points that might cause issues ## 2. Implementation Phase ### Create Feature Branch ```bash git checkout -b feature/<feature-name> ``` ### Implement Core Functionality - Write the core code following existing patterns - Ensure code quality and readability - Add appropriate error handling - Follow the project's coding standards ### Write Unit Tests - Create tests for new functionality - Aim for meaningful coverage - Test edge cases and error conditions - Ensure tests are clear and maintainable ### Update Documentation - Update relevant documentation in `docs/` - Add code comments for complex logic - Update README if public API changes ## 3. Quality Checks ### Format Code ```bash task dotnet:format ``` ### Run Pre-commit Hooks ```bash pre-commit run --all-files ``` Fix any issues found by the hooks. ### Build and Test ```bash task game:build-console task dotnet:test ``` Fix any build errors or test failures autonomously. ### Run the Application ```bash task game:run-console ``` Verify the feature works as expected. ### Self-Review - Review all changes made - Check for code quality issues - Ensure no debugging code left behind - Verify security implications ## 4. Integration Phase ### Merge Latest Changes ```bash git fetch origin main git merge origin/main ``` Resolve any conflicts if they arise. ### Run Tests Again ```bash task dotnet:test ``` Ensure integration didn't break anything. ### Create Pull Request ```bash gh pr create --title "feat: <feature-name>" --body "$(cat <<'EOF' ## Summary - Brief description of the feature - What problem it solves ## Changes - List of key changes made ## Testing - How to test the feature - Test scenarios covered ## Checklist - [x] Tests added/updated - [x] Documentation updated - [x] Pre-commit hooks pass - [x] Application runs successfully 🤖 Generated with Windsurf EOF )" ``` ## 5. Final Report Provide summary: - Feature implemented: [description] - Files changed: [count] - Tests added: [count] - PR created: [URL] - Status: Ready for review

{ "prompt": "# Feature Development Workflow\n\nComplete workflow for developing a new feature from planning to pull request.\n\n## 1. Planning Phase\n\n### Analyze Requirements\n\n- Review the feature requirements with the user if unclear\n- Understand the expected behavior and scope\n- Identify which parts of the codebase are affected\n\n### Review Existing Code\n\n- Read relevant files in the affected areas\n- Understand the current architecture and patterns\n- Identify where the feature should be integrated\n\n### Create Task Breakdown\n\n- Break down the feature into specific, implementable tasks\n- Identify dependencies between tasks\n- Estimate complexity and potential challenges\n\n### Identify Risks\n\n- Consider edge cases\n- Check for breaking changes\n- Identify integration points that might cause issues\n\n## 2. Implementation Phase\n\n### Create Feature Branch\n\n```bash\ngit checkout -b feature/<feature-name>\n```\n\n### Implement Core Functionality\n\n- Write the core code following existing patterns\n- Ensure code quality and readability\n- Add appropriate error handling\n- Follow the project's coding standards\n\n### Write Unit Tests\n\n- Create tests for new functionality\n- Aim for meaningful coverage\n- Test edge cases and error conditions\n- Ensure tests are clear and maintainable\n\n### Update Documentation\n\n- Update relevant documentation in `docs/`\n- Add code comments for complex logic\n- Update README if public API changes\n\n## 3. Quality Checks\n\n### Format Code\n\n```bash\ntask dotnet:format\n```\n\n### Run Pre-commit Hooks\n\n```bash\npre-commit run --all-files\n```\n\nFix any issues found by the hooks.\n\n### Build and Test\n\n```bash\ntask game:build-console\ntask dotnet:test\n```\n\nFix any build errors or test failures autonomously.\n\n### Run the Application\n\n```bash\ntask game:run-console\n```\n\nVerify the feature works as expected.\n\n### Self-Review\n\n- Review all changes made\n- Check for code quality issues\n- Ensure no debugging code left behind\n- Verify security implications\n\n## 4. Integration Phase\n\n### Merge Latest Changes\n\n```bash\ngit fetch origin main\ngit merge origin/main\n```\n\nResolve any conflicts if they arise.\n\n### Run Tests Again\n\n```bash\ntask dotnet:test\n```\n\nEnsure integration didn't break anything.\n\n### Create Pull Request\n\n```bash\ngh pr create --title \"feat: <feature-name>\" --body \"$(cat <<'EOF'\n## Summary\n- Brief description of the feature\n- What problem it solves\n\n## Changes\n- List of key changes made\n\n## Testing\n- How to test the feature\n- Test scenarios covered\n\n## Checklist\n- [x] Tests added/updated\n- [x] Documentation updated\n- [x] Pre-commit hooks pass\n- [x] Application runs successfully\n\n🤖 Generated with Windsurf\nEOF\n)\"\n```\n\n## 5. Final Report\n\nProvide summary:\n\n- Feature implemented: [description]\n- Files changed: [count]\n- Tests added: [count]\n- PR created: [URL]\n- Status: Ready for review", "variables": [], "notes": "Complete workflow for developing a new feature from planning to pull request.", "metadata": { "source": { "provider": "github-windsurf-workflows", "repository": "https://github.com/GiantCroissant-Lunar/pigeon-pea", "path": ".windsurf/workflows/feature.md", "ref": "d62332d0efb2b45be1a6f1350a399149f8ce494e", "url": "https://github.com/GiantCroissant-Lunar/pigeon-pea/blob/d62332d0efb2b45be1a6f1350a399149f8ce494e/.windsurf/workflows/feature.md", "key": "GiantCroissant-Lunar/pigeon-pea/.windsurf/workflows/feature.md" } } }

feature

About