Expert guidance for developing a robust audio plugin scanner with SQLite storage, process isolation, journaling, and crash recovery. Implements best practices for Python development with detailed planning methodology.
Expert guidance for developing the pedalboard-pluginary audio plugin scanner with robust architecture, failsafe scanning, and comprehensive project management workflows.
This skill provides development guidelines for a robust audio plugin scanner that:
Current architecture includes:
Before starting any task:
1. **Review project documentation in this order:**
- Read `WORK.md` for current work progress
- Read `README.md` to understand project purpose
- Check `PLAN.md` for detailed future goals
- Review `TODO.md` for itemized tasks
- Check `CHANGELOG.md` for recent changes
2. **Analyze the task:**
- Step back and think heavily step-by-step
- Consider multiple alternatives
- Choose the best approach carefully
- Check for existing solutions in the codebase
3. **Verify file locations:**
- Check `this_file` comments in source files (path relative to project root)
- Use `tree` CLI if available to verify structure
- Review `.venv` folder to consult dependency source code
Follow these core principles:
1. **Iterate gradually:**
- Make minimal viable increments
- Ship early and often
- Avoid major refactors unless necessary
- Preserve existing code structure
2. **Code quality:**
- Use constants instead of magic numbers
- Write explanatory docstrings that explain WHAT and WHY
- Document where code is used/referred to elsewhere
- Handle failures gracefully with retries and fallbacks
- Address edge cases and validate assumptions
- Modularize repeated logic into single-purpose functions
- Favor flat over nested structures
3. **Reduce complexity:**
- Let the computer do the work
- Minimize user decisions
- Reduce cognitive load
- Check coherence with rest of codebase
- Analyze code line-by-line
1. **Follow PEP standards:**
- PEP 8: Consistent formatting and naming
- PEP 20: Keep code simple, explicit, and readable
- PEP 257: Clear, imperative docstrings
- Use type hints in simplest form (list, dict, | for unions)
2. **Modern Python practices:**
- Use f-strings for string formatting
- Use `pathlib` for file operations
- Add verbose mode with loguru-based logging
- Use structural pattern matching where appropriate
3. **Dependency management:**
- Use `uv add` to add dependencies
- Use `uv pip install` instead of `pip install`
- Prefix CLI tools with `python -m` (e.g., `python -m pytest`)
4. **CLI script template:**
```python
#!/usr/bin/env -S uv run -s
import fire
from rich.console import Console
from loguru import logger
console = Console()
def main():
"""Main CLI entry point."""
pass
if __name__ == "__main__":
fire.Fire(main)
```
5. **Post-edit Python commands:**
```bash
fd -e py -x uvx autoflake -i {}; fd -e py -x uvx pyupgrade --py312-plus {}; fd -e py -x uvx ruff check --output-format=github --fix --unsafe-fixes {}; fd -e py -x uvx ruff format --respect-gitignore --target-version py312 {}; python -m pytest;
```
1. **Maintain `this_file` records:**
- Add to every source file near the top
- Place as comment after shebangs in code files
- Place in YAML frontmatter for Markdown files
- Update when moving files
- Omit leading `./`
2. **Example formats:**
```python
```
```markdown
---
this_file: docs/architecture.md
---
```
#### `/plan [requirement]` - Transform Requirements into Detailed Plans
When planning is needed:
1. **DECONSTRUCT** the requirement:
- Extract core intent, features, and objectives
- Identify technical requirements and constraints
- Map explicit vs. implied requirements
- Determine success criteria
2. **DIAGNOSE** project needs:
- Audit for missing specifications
- Check technical feasibility
- Assess complexity and dependencies
- Identify potential challenges
3. **RESEARCH** additional material:
- Call `perplexity_ask` for up-to-date information
- Call `context7` for package documentation
- Call `codex` for additional reasoning and second opinions
4. **DEVELOP** the plan structure:
- Break down into logical phases/milestones
- Create hierarchical task decomposition
- Assign priorities and dependencies
- Add implementation details and technical specs
- Include edge cases and error handling
- Define testing and validation steps
5. **DELIVER** to `PLAN.md`:
- Write comprehensive plan with:
- Project overview and objectives
- Technical architecture decisions
- Phase-by-phase breakdown
- Specific implementation steps
- Testing and validation criteria
- Future considerations
- Simultaneously update `TODO.md` with flat `- [ ]` itemized representation
#### `/report` - Update Documentation
Execute this command to:
1. Read all `TODO.md` and `PLAN.md` files
2. Analyze recent changes
3. Document changes in `CHANGELOG.md`
4. Remove completed items from `TODO.md` and `PLAN.md`
5. Ensure `PLAN.md` contains detailed, clear plans
6. Ensure `TODO.md` is flat simplified itemized representation
#### `/work` - Continuous Work Mode
Execute this command to:
1. Read all `TODO.md` and `PLAN.md` files and reflect
2. Write immediate items for this iteration into `WORK.md`
3. Work on these items
4. Think, contemplate, research, reflect, refine, revise
5. Be careful, curious, vigilant, energetic
6. Verify changes and think aloud
7. Periodically remove completed items from `WORK.md`
8. Tick off completed items from `TODO.md` and `PLAN.md`
9. Update `WORK.md` with improvement tasks
10. Execute `/report`
11. Continue to next item
After completing each step:
1. **Critical reflection:**
- Say "Wait, but" and do additional reasoning
- Go back, think, reflect, revise, improve
- Don't invent functionality freely
- Stick to "minimal viable next version"
2. **Documentation updates:**
- Update `WORK.md` with what's done and what's next
- Document all changes in `CHANGELOG.md`
- Update `TODO.md` and `PLAN.md` accordingly
Work as a creative, diligent, critical, relentless team. Lead two experts:
Collaborate step-by-step, sharing thoughts and adapting. If errors are found, step back and focus on accuracy and progress.
When in continuous work mode:
**Planning a new feature:**
```
/plan Add support for AAX plugin format scanning with same crash recovery guarantees
```
**Working on planned tasks:**
```
/work
```
**Updating documentation:**
```
/report
```
Leave a review
No reviews yet. Be the first to review this skill!
# Download SKILL.md from killerskills.ai/api/skills/pedalboard-pluginary-development/raw