Add AI Development Enforcement Foundation

[frankbria]

Summary

Implement basic enforcement mechanisms to prevent common AI agent failure modes in code generation.

Background

AI agents commonly:

• Claim tests pass without running them
• Skip failing tests claiming they're unrelated
• Add @Skip decorators to make suites pass
• Ignore coverage requirements
• Degrade in quality over long conversations

Tasks

1. Create AI Rules File

• Create .claude/rules.md with TDD requirements
• Document forbidden actions (skip decorators, false claims)
• Add context management guidelines

2. Configure Test Infrastructure

• Add pytest configuration in pyproject.toml
• Set coverage threshold at 80%
• Configure branch coverage

3. Add Pre-commit Hooks

• Install pre-commit package
• Create .pre-commit-config.yaml
• Add pytest execution hook
• Add coverage enforcement hook
• Add skip decorator detection

4. Create Verification Scripts

• Create tools/verify-ai-claims.sh
• Make executable with proper permissions
• Test script with current codebase

5. Documentation

• Update README with AI workflow
• Add examples of correct usage
• Document verification process

Success Criteria

• Pre-commit hooks block commits with failing tests
• Coverage enforcement prevents low-coverage commits
• Verification script provides clear pass/fail feedback
• Documentation clearly explains workflow

References

• See AI_Development_Enforcement_Guide.md for detailed implementation
• Quick Start section covers this issue (30 minute setup)

Implementation Notes

This is the foundation layer. Complete this issue before others as they depend on these files being in place.

Estimated Effort: 2-3 hours

[traycerai]

Plan

Observations

The codebase already has a solid test infrastructure foundation with pytest, coverage reporting (85% threshold), and 93/93 tests passing. The .claude/ directory exists with settings, and there's a verify.sh script for deployment verification. However, there are no AI development enforcement mechanisms to prevent common failure modes like skipping tests, false claims about test results, or ignoring coverage requirements. This issue implements the foundational layer that other AI enforcement features will depend on.

Approach

Implement a multi-layered AI enforcement system: (1) Create explicit AI rules documentation in .claude/rules.md defining TDD requirements and forbidden actions, (2) Add pre-commit hooks to automatically verify tests pass and coverage meets thresholds before commits, (3) Create a verification script that AI agents can run to validate their claims, (4) Update project configuration to include pre-commit as a dev dependency, and (5) Document the AI workflow in the README. This approach uses automation to enforce good practices rather than relying on AI agent compliance.

Reasoning

I explored the repository structure to understand the existing test infrastructure, examined pyproject.toml, pytest.ini, and .coveragerc to see current configurations, checked for existing pre-commit hooks and AI rules (none found), reviewed the README and testing documentation to understand the project's testing standards, and confirmed that 93/93 tests are currently passing with 85% coverage threshold already configured.

Proposed File Changes

📄 .claude/rules.md ^(NEW) 🔗

References

• 📄 TESTING.md
• 📄 .coveragerc
• 📄 pytest.ini

Create a comprehensive AI development rules file that establishes clear guidelines for AI agents working on this codebase. Include three main sections:

1. TDD Requirements: Document the strict Test-Driven Development workflow that must be followed - write tests first (RED), implement code to pass tests (GREEN), then refactor (REFACTOR). Reference the existing TESTING.md file for detailed testing procedures. Specify that all new features require tests before implementation and that test coverage must meet the 85% threshold defined in .coveragerc.

2. Forbidden Actions: Explicitly list actions that AI agents must never take:

   • Never add @pytest.mark.skip, @unittest.skip, or similar decorators to make test suites pass
   • Never claim tests pass without actually running them
   • Never skip failing tests claiming they are "unrelated" without investigation
   • Never ignore coverage requirements or lower thresholds
   • Never commit code with failing tests
   • Never make false claims about verification results

3. Context Management Guidelines: Provide guidance on maintaining conversation quality over long sessions:

   • Run verification scripts before claiming completion
   • Use the tools/verify-ai-claims.sh script to validate all claims
   • Reference specific test output and coverage reports
   • Keep responses focused and avoid degrading quality in long conversations
   • When uncertain, ask for clarification rather than making assumptions

4. Verification Process: Document the step-by-step process for verifying work:

   • Run pytest to execute all tests
   • Run pytest --cov=codeframe --cov-report=term-missing to check coverage
   • Run tools/verify-ai-claims.sh for comprehensive validation
   • Review pre-commit hook results before claiming success

Format this as a clear, actionable markdown document that AI agents will reference during development.

📄 pyproject.toml ^(MODIFY) 🔗

Update the [project.optional-dependencies] section to add pre-commit to the dev dependencies list. Add it after the existing dev dependencies (pytest, pytest-asyncio, pytest-cov, pytest-json-report, black, ruff, mypy) with version constraint >=3.5.0 to ensure compatibility with Python 3.11+.

Also add a new [tool.coverage.run] section if it doesn't exist to enable branch coverage tracking (this complements the existing .coveragerc configuration). Set branch = true to track both line and branch coverage, which provides more comprehensive coverage metrics and helps catch untested code paths.

📄 .pre-commit-config.yaml ^(NEW) 🔗

References

• 📄 .coveragerc
• 📄 pytest.ini
• 📄 tests/conftest.py

Create a pre-commit configuration file with multiple hooks to enforce code quality and testing standards:

1. Standard Pre-commit Hooks: Include basic hooks from the pre-commit-hooks repository:

   • trailing-whitespace: Remove trailing whitespace
   • end-of-file-fixer: Ensure files end with newline
   • check-yaml: Validate YAML syntax
   • check-added-large-files: Prevent committing large files
   • check-merge-conflict: Detect merge conflict markers

2. Python Code Quality Hooks:

   • black: Auto-format Python code (already in dev dependencies)
   • ruff: Lint Python code (already in dev dependencies)

3. Test Execution Hook: Create a local hook that runs pytest before allowing commits:

   • Hook ID: pytest-check
   • Name: "Run pytest tests"
   • Entry point: pytest tests/ -v --tb=short
   • Language: system
   • Pass filenames: false
   • Always run: true
   • This ensures all tests pass before code can be committed

4. Coverage Enforcement Hook: Create a local hook that verifies coverage meets the 85% threshold:

   • Hook ID: coverage-check
   • Name: "Check test coverage"
   • Entry point: pytest --cov=codeframe --cov-report=term --cov-fail-under=85
   • Language: system
   • Pass filenames: false
   • Always run: true
   • This enforces the coverage threshold defined in .coveragerc

5. Skip Decorator Detection Hook: Create a local hook that scans for forbidden skip decorators:

   • Hook ID: detect-skip-decorators
   • Name: "Detect @Skip decorators"
   • Entry point: bash -c 'if grep -r "@pytest.mark.skip\|@unittest.skip\|@skip" tests/ --include="*.py" | grep -v "conftest.py"; then echo "ERROR: Skip decorators found in tests!"; exit 1; fi'
   • Language: system
   • Pass filenames: false
   • Always run: true
   • Exclude the legitimate use in conftest.py for API key checks

Configure all hooks to run on commit. Set fail_fast: false to run all hooks even if one fails, providing complete feedback.

📁 tools ^(NEW) 🔗

Create a new directory to house verification and utility scripts for the project. This directory will contain scripts that AI agents and developers can use to verify their work meets project standards.

📄 tools/verify-ai-claims.sh ^(NEW) 🔗

References

• 📄 verify.sh
• 📄 .coveragerc
• 📄 pytest.ini

Create a comprehensive verification script that AI agents must run before claiming their work is complete. This script should provide clear pass/fail feedback with detailed output.

Implement the following verification steps:

1. Header and Setup:

   • Add shebang: #!/bin/bash
   • Set strict error handling: set -euo pipefail
   • Define color codes for output (green for pass, red for fail, yellow for warnings)
   • Initialize pass/fail counters

2. Python Environment Check:

   • Verify virtual environment is activated or Python is available
   • Check that required packages are installed (pytest, pytest-cov)
   • Print Python version and pytest version

3. Test Execution Verification:

   • Run pytest tests/ -v --tb=short and capture output
   • Parse output to extract number of tests passed/failed
   • Display test results with clear formatting
   • Fail if any tests fail or if no tests are found

4. Coverage Verification:

   • Run pytest --cov=codeframe --cov-report=term-missing --cov-fail-under=85
   • Parse coverage percentage from output
   • Display coverage results with threshold comparison
   • Fail if coverage is below 85%
   • Show which files/lines are missing coverage

5. Skip Decorator Detection:

   • Search for @pytest.mark.skip, @unittest.skip, @skip in test files
   • Exclude legitimate uses in conftest.py
   • Report any forbidden skip decorators found
   • Fail if any are detected

6. Code Quality Checks (optional, non-blocking):

   • Run ruff check . if available
   • Run black --check . if available
   • Report issues but don't fail the script

7. Summary Report:

   • Display a clear summary of all checks
   • Show total pass/fail count
   • Provide actionable next steps if failures detected
   • Exit with code 0 if all checks pass, 1 if any fail

8. Usage Instructions:

   • Add comments at the top explaining how to run the script
   • Document what each check does
   • Provide examples of expected output

The script should be verbose and educational, helping AI agents understand what's being checked and why. Reference the existing verify.sh script for inspiration on structure and output formatting, but make this script focused on AI development verification rather than deployment verification.

📄 README.md ^(MODIFY) 🔗

References

• 📄 .claude/rules.md ^(NEW)
• 📄 tools/verify-ai-claims.sh ^(NEW)
• 📄 .pre-commit-config.yaml ^(NEW)

Add a new section titled "## AI Development Workflow" after the "## Testing" section (around line 595). This section should document the AI enforcement mechanisms and how AI agents should work with this codebase.

Include the following subsections:

1. AI Development Rules: Briefly introduce the .claude/rules.md file and its purpose. Explain that AI agents must follow TDD practices and avoid common failure modes. Link to the rules file for complete details.

2. Verification Process: Document the step-by-step verification process:

   • Run tests: pytest
   • Check coverage: pytest --cov=codeframe --cov-report=term-missing
   • Run verification script: ./tools/verify-ai-claims.sh
   • Review pre-commit results before committing

3. Pre-commit Hooks: Explain that pre-commit hooks automatically enforce quality standards:

   • How to install: pip install -e ".[dev]" then pre-commit install
   • What hooks run: test execution, coverage checks, skip decorator detection
   • How to run manually: pre-commit run --all-files
   • Note that hooks must pass before commits are allowed

4. Forbidden Actions: Provide a quick reference list of actions AI agents must never take (summarized from .claude/rules.md):

   • Never add skip decorators to tests
   • Never claim tests pass without running them
   • Never ignore coverage requirements
   • Always verify claims with the verification script

5. Example Workflow: Show a complete example of the correct AI development workflow:

   # 1. Write tests first (TDD RED phase)
   # Create test file: tests/test_new_feature.py
   
   # 2. Verify tests fail as expected
   pytest tests/test_new_feature.py -v
   
   # 3. Implement feature (TDD GREEN phase)
   # Create implementation: codeframe/new_feature.py
   
   # 4. Verify tests pass
   pytest tests/test_new_feature.py -v
   
   # 5. Check coverage
   pytest --cov=codeframe --cov-report=term-missing
   
   # 6. Run full verification
   ./tools/verify-ai-claims.sh
   
   # 7. Commit (pre-commit hooks run automatically)
   git add .
   git commit -m "feat: add new feature with tests"

6. Troubleshooting: Add common issues and solutions:

   • Pre-commit hooks failing: Run verification script to see detailed errors
   • Coverage below threshold: Use --cov-report=html to see missing lines
   • Tests failing: Check test output with -v --tb=short for details

Keep the section concise but comprehensive, focusing on practical guidance. Reference the existing "## Testing" section for detailed testing procedures and the new .claude/rules.md for complete AI development rules.

📄 CONTRIBUTING.md ^(MODIFY) 🔗

References

• 📄 .claude/rules.md ^(NEW)
• 📄 tools/verify-ai-claims.sh ^(NEW)
• 📄 .coveragerc

Add a new section titled "## AI Agent Development" near the beginning of the file (after the introduction but before detailed contribution guidelines). This section should specifically address AI agents contributing to the codebase.

Include:

1. AI Development Standards: Reference the .claude/rules.md file as the authoritative source for AI development guidelines. Emphasize that AI agents must follow TDD practices and use the verification tools.

2. Required Verification: State that all AI-generated code must pass the verification script (tools/verify-ai-claims.sh) before being considered complete. Explain that this is non-negotiable and helps maintain code quality.

3. Pre-commit Hook Compliance: Explain that pre-commit hooks are mandatory and will automatically run on every commit. AI agents should run pre-commit run --all-files before claiming work is complete to catch issues early.

4. Test Coverage Requirements: Reiterate the 85% coverage threshold and explain that this is enforced automatically by pre-commit hooks. Link to the .coveragerc file for configuration details.

5. Quality Over Speed: Emphasize that the project values correct, well-tested code over rapid iteration. AI agents should take time to verify their work thoroughly rather than rushing to completion.

Keep this section brief (10-15 lines) since the detailed guidelines are in .claude/rules.md. The goal is to make AI agents aware of the special requirements and point them to the right resources.

Import In IDE

🤖 Prompt for AI Agents

I have created the following plan after thorough exploration and analysis of the codebase. Follow the below plan verbatim. Trust the files and references. Do not re-verify what's written in the plan. Explore only when absolutely necessary. First implement all the proposed file changes and then I'll review all the changes together at the end.

### Observations

The codebase already has a solid test infrastructure foundation with pytest, coverage reporting (85% threshold), and 93/93 tests passing. The `.claude/` directory exists with settings, and there's a `verify.sh` script for deployment verification. However, there are no AI development enforcement mechanisms to prevent common failure modes like skipping tests, false claims about test results, or ignoring coverage requirements. This issue implements the foundational layer that other AI enforcement features will depend on.


### Approach

Implement a multi-layered AI enforcement system: (1) Create explicit AI rules documentation in `.claude/rules.md` defining TDD requirements and forbidden actions, (2) Add pre-commit hooks to automatically verify tests pass and coverage meets thresholds before commits, (3) Create a verification script that AI agents can run to validate their claims, (4) Update project configuration to include pre-commit as a dev dependency, and (5) Document the AI workflow in the README. This approach uses automation to enforce good practices rather than relying on AI agent compliance.


### Reasoning

I explored the repository structure to understand the existing test infrastructure, examined `pyproject.toml`, `pytest.ini`, and `.coveragerc` to see current configurations, checked for existing pre-commit hooks and AI rules (none found), reviewed the README and testing documentation to understand the project's testing standards, and confirmed that 93/93 tests are currently passing with 85% coverage threshold already configured.


## Proposed File Changes

### .claude/rules.md(NEW)

References: 

- TESTING.md
- .coveragerc
- pytest.ini

Create a comprehensive AI development rules file that establishes clear guidelines for AI agents working on this codebase. Include three main sections:

1. **TDD Requirements**: Document the strict Test-Driven Development workflow that must be followed - write tests first (RED), implement code to pass tests (GREEN), then refactor (REFACTOR). Reference the existing `TESTING.md` file for detailed testing procedures. Specify that all new features require tests before implementation and that test coverage must meet the 85% threshold defined in `.coveragerc`.

2. **Forbidden Actions**: Explicitly list actions that AI agents must never take:
   - Never add `@pytest.mark.skip`, `@unittest.skip`, or similar decorators to make test suites pass
   - Never claim tests pass without actually running them
   - Never skip failing tests claiming they are "unrelated" without investigation
   - Never ignore coverage requirements or lower thresholds
   - Never commit code with failing tests
   - Never make false claims about verification results

3. **Context Management Guidelines**: Provide guidance on maintaining conversation quality over long sessions:
   - Run verification scripts before claiming completion
   - Use the `tools/verify-ai-claims.sh` script to validate all claims
   - Reference specific test output and coverage reports
   - Keep responses focused and avoid degrading quality in long conversations
   - When uncertain, ask for clarification rather than making assumptions

4. **Verification Process**: Document the step-by-step process for verifying work:
   - Run `pytest` to execute all tests
   - Run `pytest --cov=codeframe --cov-report=term-missing` to check coverage
   - Run `tools/verify-ai-claims.sh` for comprehensive validation
   - Review pre-commit hook results before claiming success

Format this as a clear, actionable markdown document that AI agents will reference during development.

### pyproject.toml(MODIFY)

Update the `[project.optional-dependencies]` section to add `pre-commit` to the dev dependencies list. Add it after the existing dev dependencies (pytest, pytest-asyncio, pytest-cov, pytest-json-report, black, ruff, mypy) with version constraint `>=3.5.0` to ensure compatibility with Python 3.11+.

Also add a new `[tool.coverage.run]` section if it doesn't exist to enable branch coverage tracking (this complements the existing `.coveragerc` configuration). Set `branch = true` to track both line and branch coverage, which provides more comprehensive coverage metrics and helps catch untested code paths.

### .pre-commit-config.yaml(NEW)

References: 

- .coveragerc
- pytest.ini
- tests/conftest.py

Create a pre-commit configuration file with multiple hooks to enforce code quality and testing standards:

1. **Standard Pre-commit Hooks**: Include basic hooks from the pre-commit-hooks repository:
   - `trailing-whitespace`: Remove trailing whitespace
   - `end-of-file-fixer`: Ensure files end with newline
   - `check-yaml`: Validate YAML syntax
   - `check-added-large-files`: Prevent committing large files
   - `check-merge-conflict`: Detect merge conflict markers

2. **Python Code Quality Hooks**:
   - `black`: Auto-format Python code (already in dev dependencies)
   - `ruff`: Lint Python code (already in dev dependencies)

3. **Test Execution Hook**: Create a local hook that runs pytest before allowing commits:
   - Hook ID: `pytest-check`
   - Name: "Run pytest tests"
   - Entry point: `pytest tests/ -v --tb=short`
   - Language: system
   - Pass filenames: false
   - Always run: true
   - This ensures all tests pass before code can be committed

4. **Coverage Enforcement Hook**: Create a local hook that verifies coverage meets the 85% threshold:
   - Hook ID: `coverage-check`
   - Name: "Check test coverage"
   - Entry point: `pytest --cov=codeframe --cov-report=term --cov-fail-under=85`
   - Language: system
   - Pass filenames: false
   - Always run: true
   - This enforces the coverage threshold defined in `.coveragerc`

5. **Skip Decorator Detection Hook**: Create a local hook that scans for forbidden skip decorators:
   - Hook ID: `detect-skip-decorators`
   - Name: "Detect @skip decorators"
   - Entry point: `bash -c 'if grep -r "@pytest.mark.skip\|@unittest.skip\|@skip" tests/ --include="*.py" | grep -v "conftest.py"; then echo "ERROR: Skip decorators found in tests!"; exit 1; fi'`
   - Language: system
   - Pass filenames: false
   - Always run: true
   - Exclude the legitimate use in `conftest.py` for API key checks

Configure all hooks to run on commit. Set `fail_fast: false` to run all hooks even if one fails, providing complete feedback.

### tools(NEW)

Create a new directory to house verification and utility scripts for the project. This directory will contain scripts that AI agents and developers can use to verify their work meets project standards.

### tools/verify-ai-claims.sh(NEW)

References: 

- verify.sh
- .coveragerc
- pytest.ini

Create a comprehensive verification script that AI agents must run before claiming their work is complete. This script should provide clear pass/fail feedback with detailed output.

Implement the following verification steps:

1. **Header and Setup**:
   - Add shebang: `#!/bin/bash`
   - Set strict error handling: `set -euo pipefail`
   - Define color codes for output (green for pass, red for fail, yellow for warnings)
   - Initialize pass/fail counters

2. **Python Environment Check**:
   - Verify virtual environment is activated or Python is available
   - Check that required packages are installed (pytest, pytest-cov)
   - Print Python version and pytest version

3. **Test Execution Verification**:
   - Run `pytest tests/ -v --tb=short` and capture output
   - Parse output to extract number of tests passed/failed
   - Display test results with clear formatting
   - Fail if any tests fail or if no tests are found

4. **Coverage Verification**:
   - Run `pytest --cov=codeframe --cov-report=term-missing --cov-fail-under=85`
   - Parse coverage percentage from output
   - Display coverage results with threshold comparison
   - Fail if coverage is below 85%
   - Show which files/lines are missing coverage

5. **Skip Decorator Detection**:
   - Search for `@pytest.mark.skip`, `@unittest.skip`, `@skip` in test files
   - Exclude legitimate uses in `conftest.py`
   - Report any forbidden skip decorators found
   - Fail if any are detected

6. **Code Quality Checks** (optional, non-blocking):
   - Run `ruff check .` if available
   - Run `black --check .` if available
   - Report issues but don't fail the script

7. **Summary Report**:
   - Display a clear summary of all checks
   - Show total pass/fail count
   - Provide actionable next steps if failures detected
   - Exit with code 0 if all checks pass, 1 if any fail

8. **Usage Instructions**:
   - Add comments at the top explaining how to run the script
   - Document what each check does
   - Provide examples of expected output

The script should be verbose and educational, helping AI agents understand what's being checked and why. Reference the existing `verify.sh` script for inspiration on structure and output formatting, but make this script focused on AI development verification rather than deployment verification.

### README.md(MODIFY)

References: 

- .claude/rules.md(NEW)
- tools/verify-ai-claims.sh(NEW)
- .pre-commit-config.yaml(NEW)

Add a new section titled "## AI Development Workflow" after the "## Testing" section (around line 595). This section should document the AI enforcement mechanisms and how AI agents should work with this codebase.

Include the following subsections:

1. **AI Development Rules**: Briefly introduce the `.claude/rules.md` file and its purpose. Explain that AI agents must follow TDD practices and avoid common failure modes. Link to the rules file for complete details.

2. **Verification Process**: Document the step-by-step verification process:
   - Run tests: `pytest`
   - Check coverage: `pytest --cov=codeframe --cov-report=term-missing`
   - Run verification script: `./tools/verify-ai-claims.sh`
   - Review pre-commit results before committing

3. **Pre-commit Hooks**: Explain that pre-commit hooks automatically enforce quality standards:
   - How to install: `pip install -e ".[dev]"` then `pre-commit install`
   - What hooks run: test execution, coverage checks, skip decorator detection
   - How to run manually: `pre-commit run --all-files`
   - Note that hooks must pass before commits are allowed

4. **Forbidden Actions**: Provide a quick reference list of actions AI agents must never take (summarized from `.claude/rules.md`):
   - Never add skip decorators to tests
   - Never claim tests pass without running them
   - Never ignore coverage requirements
   - Always verify claims with the verification script

5. **Example Workflow**: Show a complete example of the correct AI development workflow:
   ```bash
   # 1. Write tests first (TDD RED phase)
   # Create test file: tests/test_new_feature.py
   
   # 2. Verify tests fail as expected
   pytest tests/test_new_feature.py -v
   
   # 3. Implement feature (TDD GREEN phase)
   # Create implementation: codeframe/new_feature.py
   
   # 4. Verify tests pass
   pytest tests/test_new_feature.py -v
   
   # 5. Check coverage
   pytest --cov=codeframe --cov-report=term-missing
   
   # 6. Run full verification
   ./tools/verify-ai-claims.sh
   
   # 7. Commit (pre-commit hooks run automatically)
   git add .
   git commit -m "feat: add new feature with tests"
   ```

6. **Troubleshooting**: Add common issues and solutions:
   - Pre-commit hooks failing: Run verification script to see detailed errors
   - Coverage below threshold: Use `--cov-report=html` to see missing lines
   - Tests failing: Check test output with `-v --tb=short` for details

Keep the section concise but comprehensive, focusing on practical guidance. Reference the existing "## Testing" section for detailed testing procedures and the new `.claude/rules.md` for complete AI development rules.

### CONTRIBUTING.md(MODIFY)

References: 

- .claude/rules.md(NEW)
- tools/verify-ai-claims.sh(NEW)
- .coveragerc

Add a new section titled "## AI Agent Development" near the beginning of the file (after the introduction but before detailed contribution guidelines). This section should specifically address AI agents contributing to the codebase.

Include:

1. **AI Development Standards**: Reference the `.claude/rules.md` file as the authoritative source for AI development guidelines. Emphasize that AI agents must follow TDD practices and use the verification tools.

2. **Required Verification**: State that all AI-generated code must pass the verification script (`tools/verify-ai-claims.sh`) before being considered complete. Explain that this is non-negotiable and helps maintain code quality.

3. **Pre-commit Hook Compliance**: Explain that pre-commit hooks are mandatory and will automatically run on every commit. AI agents should run `pre-commit run --all-files` before claiming work is complete to catch issues early.

4. **Test Coverage Requirements**: Reiterate the 85% coverage threshold and explain that this is enforced automatically by pre-commit hooks. Link to the `.coveragerc` file for configuration details.

5. **Quality Over Speed**: Emphasize that the project values correct, well-tested code over rapid iteration. AI agents should take time to verify their work thoroughly rather than rushing to completion.

Keep this section brief (10-15 lines) since the detailed guidelines are in `.claude/rules.md`. The goal is to make AI agents aware of the special requirements and point them to the right resources.

---

Developer Humor

🤖 An AI agent walks into a codebase...\n> \I'll just skip these failing tests,\ it says.\n> Pre-commit hook: \Not on my watch!\n> 🚫 COMMIT BLOCKED\n> \n> The agent sighs, fixes the tests properly.\n> ✅ All checks pass. Commit succeeds.\n> \Guess I'll do it right the first time,\ it mutters.\n> \n> 🎯 Automation: Teaching AIs good habits since 2025

---

Execution Information

Branch: main
Commit: d0e2480

---

💡 Tips

Supported Commands (Inside Comments)

• Use @traycerai generate to iterate on the previous version of the implementation plan.

Supported Commands (Inside Description)

• Add @traycerai ignore anywhere in the ticket description to prevent this ticket from being processed.
• Add @traycerai branch:<branch-name> anywhere in the ticket description to specify the target branch for the implementation plan.

Community

• Join our Discord Community to get help, request features, and share feedback.
• Follow us on X/Twitter for updates and announcements.

[frankbria]

Resolved in PR #20 - Sprint 8: AI Quality Enforcement complete. All enforcement foundation features implemented including .claude/rules.md, .pre-commit-config.yaml, and scripts/verify-ai-claims.sh.