CR

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.zip

Installs 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.
126 charsno explicit “when” trigger
Intermediate

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

You give it
Project files including `.claude/context/project-overview.md`, `src/` directory, `README.md`, and tests
You get back
GitHub issues for bugs or feature requests, and a verbal summary of the critique

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 used
  • src/ directory - The actual implementation
  • README.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.

SkillInstallsUpdatedSafetyDifficulty
critique (this skill)06moReviewIntermediate
effective-go3239moNo flagsBeginner
architect-review1094moNo flagsAdvanced
resolve-conflicts818moReviewIntermediate

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.

323536

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.

109320

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.

81334

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.

57236

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.

77204

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.

32238

Search skills

Search the agent skills registry