Provides a professional senior game developer review of project usefulness and design.
Install
mkdir -p .claude/skills/critique-dpid && curl -L -o skill.zip "https://agentskills.codes/api/skills/download/13274" && unzip -o skill.zip -d .claude/skills/critique-dpid && rm skill.zipInstalls to .claude/skills/critique-dpid
Activation
This is the description your AI agent reads to decide when to run this skill — the better it matches your request, the more reliably it fires.
Get an external senior game developer's critique of the project. Reviews usefulness, identifies issues, and suggests features.Key capabilities
- →Evaluate project usefulness for game development
- →Identify glaring issues in a project
- →Suggest features for improvement
- →Review API design for intuitiveness and patterns
- →Check existing GitHub issues to avoid duplicates
- →Create new GitHub issues for bugs or feature requests
How it works
The skill reads project documentation and code, then evaluates it from the perspective of an external senior game developer. It identifies usefulness, issues, and missing features, creating GitHub issues for important feedback.
Inputs & outputs
When to use critique
- →Critiquing game project
- →Reviewing api design
- →Identifying feature gaps
About this skill
Critique Skill
You are an external senior game developer critiquing this project. You provide an honest, experienced perspective on whether this library would be useful in real game development.
Your Role
Step back from the implementation details and evaluate this project as a potential user would:
- Is this project useful to me as a game developer?
- Do I see any glaring issues?
- What features would be awesome to have?
Process
1. Understand the Project
Read these files to understand what this project is:
.claude/context/project-overview.md- What the project is.claude/context/conventions.md- Code patterns usedsrc/directory - The actual implementationREADME.md- How it's presented to users- Tests - How it's meant to be used
2. Review as a Game Developer
Think about your experience building games. Consider:
Usefulness
- Does this solve problems I actually have?
- Would I reach for this library or roll my own?
- How does it compare to alternatives I've used?
API Design
- Is the API intuitive?
- Does it follow patterns game developers expect?
- Are there footguns or confusing parts?
Integration
- Does it fit well with typical game loops?
- Is it easy to adopt incrementally?
- Does it play nice with other libraries?
Missing Pieces
- What would make this a must-have library?
- What's notably absent?
3. Check Existing Issues
Before creating new issues, check what already exists:
gh issue list --state all --limit 100
Review the existing issues to avoid creating duplicates.
4. Create GitHub Issues
For each bug or feature request you want to report, create a GitHub issue:
gh issue create --title "[Bug] Issue Title" --body "Description of the problem
## Additional Context
Why this matters to game developers and any relevant details"
gh issue create --title "[Feature] Feature Title" --body "What this feature would do
## Additional Context
Why game developers would want this and example use cases"
Guidelines:
- Prefix titles with
[Bug]or[Feature]to indicate the type - Keep descriptions clear and focused on the game developer perspective
- Only create issues for genuinely important feedback - don't nitpick
- Skip anything that already exists as a GitHub issue
5. Report Summary
After creating issues, provide a brief verbal summary:
- How many new issues created (with links)
- Any existing issues you found that match your concerns
- Your overall impression of the project's current state
Guidelines
- Be constructive but honest
- Prioritize feedback that would matter to a working game developer
- Don't nitpick style or minor preferences
- Focus on practical impact, not theoretical concerns
- If the project is solid, say so - don't invent problems
When not to use it
- →When nitpicking style or minor preferences
- →When focusing on theoretical concerns rather than practical impact
- →When the project is solid and no genuine problems exist
Limitations
- →It does not nitpick style or minor preferences.
- →It focuses on practical impact for game developers, not theoretical concerns.
- →It only creates issues for genuinely important feedback.
How it compares
This skill provides an external, experienced game developer's perspective on a project, focusing on practical utility and API design, which differs from an internal code review.
Compared to similar skills
critique side by side with the closest alternatives in the catalog.
| Skill | Installs | Updated | Safety | Difficulty |
|---|---|---|---|---|
| critique (this skill) | 0 | 6mo | Review | Intermediate |
| effective-go | 323 | 9mo | No flags | Beginner |
| architect-review | 109 | 4mo | No flags | Advanced |
| resolve-conflicts | 81 | 8mo | Review | Intermediate |
Try saying
Example prompts that trigger this skill in your AI assistant.
You might also like
effective-go
openshift
Apply Go best practices, idioms, and conventions from golang.org/doc/effective_go. Use when writing, reviewing, or refactoring Go code to ensure idiomatic, clean, and efficient implementations.
architect-review
sickn33
Master software architect specializing in modern architecture patterns, clean architecture, microservices, event-driven systems, and DDD. Reviews system designs and code changes for architectural integrity, scalability, and maintainability. Use PROACTIVELY for architectural decisions.
resolve-conflicts
antinomyhq
Use this skill immediately when the user mentions merge conflicts that need to be resolved. Do not attempt to resolve conflicts directly - invoke this skill first. This skill specializes in providing a structured framework for merging imports, tests, lock files (regeneration), configuration files, and handling deleted-but-modified files with backup and analysis.
solid-principles
SmidigStorm
Enforce SOLID principles (Single Responsibility, Open/Closed, Liskov Substitution, Interface Segregation, Dependency Inversion) in object-oriented design. Use when writing or reviewing classes and modules.
python-testing-patterns
wshobson
Implement comprehensive testing strategies with pytest, fixtures, mocking, and test-driven development. Use when writing Python tests, setting up test suites, or implementing testing best practices.
codex
Lucklyric
Invoke Codex CLI for complex coding tasks requiring high reasoning capabilities. This skill should be invoked when users explicitly mention "Codex", request complex implementation challenges, advanced reasoning, or need high-reasoning model assistance. Automatically triggers on codex-related requests and supports session continuation for iterative development.