Deploy an agent

Learn center

Master the Awesome Reviewers workflow

Follow curated tutorials to go from browsing reviewer prompts to automating CI feedback with Claude Skills and the Awesome Reviewers toolchain.

Start with the guided path Browse featured tutorials Inspect the skills catalog

Featured guides

These walkthroughs mirror the flow experienced teams use: choose the right reviewer, adapt it to your repository, and export a matching Claude Skill.

Reviewers

Pick the right reviewer for your pull request

Learn how to filter the library, evaluate heuristics, and pull the exact snippet you need for VS Code, Cursor, or your agent.

  • Explore search filters and reviewer categories.
  • Compare missions, heuristics, and examples.
  • Copy the system prompt with context-aware tips.
Browse reviewer library Follow the guided setup
Skills

Generate Claude Skills from reviewer prompts

Convert your selected reviewers into reusable Claude Skills with our CLI, ready for workflows, the Claude desktop app, or API integrations.

  • Install the Awesome Reviewers CLI dependencies.
  • Export an individual reviewer or an entire category.
  • Publish SKILL.md bundles alongside your codebase.
See the Claude Skills guide View skill exports
Automation

Automate reviews across your CI and agents

Wire the prompts and skills into bots, scheduled runs, or repository checks so feedback lands before humans even open the PR.

  • Sync reviewers with GitHub Actions or your CI runner.
  • Trigger Claude Skills during dependency or security scans.
  • Collect run feedback and iterate on custom reviewers.
Understand the methodology See how the community applies them

Explore the Claude Skills catalog

Dive into the reusable Claude Skills generated from the Awesome Reviewers library and preview the guidance bundled inside each export.

AI-Assisted Development

Leveraging AI coding assistants and tools to boost development productivity, while maintaining oversight to ensure quality results.

Key guidelines
  • Embrace AI Tools: Integrate AI assistants into your workflow for tasks like code generation, documentation drafting, and test case suggestions. These tools can significantly boost productivity for routine coding tasks.
  • Validate AI Output: Always review and test code produced by AI. Treat AI suggestions as helpful drafts, not final solutions. It’s a critical skill to critique and improve AI-generated code – add missing error handling, fix inefficient logic, and ensure it fits your project’s style and requirements.
  • Stay in Control: Use AI to augment your work, not replace your thinking. Be aware of known limitations (AI might produce insecure or incorrect code). Maintain rigorous quality practices (code reviews, tests) for AI-written code just as you would for human-written code to ensure reliability.
Example scenarios
  • Using an AI pair programmer to generate a boilerplate module, then refining and optimizing that code manually.
  • Asking an AI tool to explain a piece of code or suggest fixes for a bug, speeding up the debugging process while double-checking its suggestions.
View SKILL.md on GitHub

Code Readability & Maintainability

Writing clean, understandable, and self-documenting code that is easy to review and maintain over time.

Key guidelines
  • Descriptive Naming: Choose specific, descriptive names for variables, functions, and classes. Names should communicate intent and avoid ambiguity. For example, prefer getUserProfile() over getData() to make the code self-explanatory.
  • Clarity Over Cleverness: Opt for explicit and straightforward code constructs rather than implicit or overly clever ones. For instance, use clear type conversions and named constants instead of magic numbers or implicit casts. This improves readability and avoids confusion.
  • Maintainability: Keep code structure simple and organized. Write code in a way that reduces cognitive load on the reader – e.g. clear logic flow and consistent style. Clean, readable code is easier to debug and prevents subtle bugs that can arise from unclear operations.
Example scenarios
  • Using meaningful variable and function names (isServerConnected instead of enabled) to convey intent.
  • Replacing a cryptic one-liner with a few well-named intermediate variables that make the logic obvious.
View SKILL.md on GitHub

Code Refactoring & Simplicity

The practice of restructuring and simplifying code continuously – reducing complexity, improving design, and keeping codebases clean.

Key guidelines
  • Decompose Large Functions: If a function is doing too much or exceeds roughly 50 lines, split it into smaller, focused functions. Each function should ideally handle one responsibility. This makes the code easier to understand and test.
  • Simplify Complex Logic: Reduce nesting and complexity in control flow. Apply the “exit early” principle to handle edge cases upfront and avoid deep nested if/else blocks. For example, return early on error conditions instead of wrapping the main logic in an else-clause.
  • Eliminate Redundancy: Refactor to remove duplicate or convoluted code. Break down complex boolean expressions or chained operations into simpler steps. Simplifying tricky code by using clearer constructs or standard library functions makes it more approachable and reduces potential bugs.
Example scenarios
  • Splitting a 300-line function that does many things into smaller helper functions each focused on one task.
  • Removing duplicate code by refactoring it into a reusable module or library.
View SKILL.md on GitHub

Collaboration & Open Source Contribution

Working effectively with others in coding projects – including code reviews, clear communication, and contributing to shared or open-source codebases.

Key guidelines
  • Code Review Mastery: Engage in code reviews regularly. Read others’ code and provide helpful suggestions, and incorporate feedback from reviewers on your code. For example, if reviewers suggest a function be split for clarity, be willing to refactor. Code review culture leads to better code quality and knowledge transfer.
  • Open Source Engagement: Consider contributing to open-source projects or internal company repositories. This exposes you to large-scale codebases and different perspectives. It’s also a great way to demonstrate skills. Always follow the project’s contribution guidelines when submitting changes.
  • Team Communication: Maintain clear and professional communication with team members. Document decisions, update project artifacts, and respect established team conventions. By aligning with team processes, you build trust and velocity in development.
Example scenarios
  • Participating in code review: reviewing a colleague’s pull request and providing constructive feedback, as well as responding to feedback on your own code.
  • Contributing a bug fix or new feature to an open-source project, following the project’s contribution guidelines and coding style.
View SKILL.md on GitHub

Data & Machine Learning Proficiency

Competence in data analytics and machine learning, enabling developers to build data-driven features and integrate AI/ML capabilities.

Key guidelines
  • Learn Data Tools: Gain proficiency with data-focused languages and libraries. For example, Python paired with libraries such as NumPy and Pandas is extremely popular for data tasks. This enables you to perform analysis or preprocessing as part of your development work.
  • Understand ML Workflows: Even if you’re not a data scientist, understand the basics of training and using machine learning models. Know how to use ML frameworks or services (TensorFlow, PyTorch, scikit-learn, or cloud ML APIs) to add AI capabilities to applications.
  • Data-Driven Decision Making: Use data to inform development decisions. This could mean instrumenting your app with analytics (and then querying that data), or A/B testing features. A developer who can derive insights from data and adjust software accordingly will create more effective, user-optimized products.
Example scenarios
  • Using Python libraries like Pandas and NumPy to manipulate and analyze data for an application feature.
  • Integrating a pre-trained machine learning model (e.g. image recognition, NLP) into a web service or app.
View SKILL.md on GitHub

DevOps & Cloud Infrastructure

Skill in automating software deployment pipelines and managing cloud infrastructure for scalable, reliable systems.

Key guidelines
  • Cloud Platform Proficiency: Learn to deploy and manage applications on cloud services (AWS, Azure, GCP). AWS remains hugely popular, used by over half of developers, due to its broad ecosystem. Knowing how to configure servers, storage, and networks in a cloud environment is key.
  • CI/CD Automation: Embrace continuous integration and deployment. Automate build, test, and deployment workflows using tools like GitHub Actions, Jenkins, or GitLab CI. Containerization (e.g. Docker) is widely used in CI/CD pipelines to ensure consistent deployments across environments.
  • Infrastructure as Code: Manage infrastructure with code (Terraform, CloudFormation) and configuration management. Treat operations tasks (provisioning servers, setting up load balancers, monitoring) as part of the development process to enable rapid, reliable releases.
Example scenarios
  • Setting up a CI/CD pipeline that builds, tests, and deploys an application to AWS or Azure.
  • Containerizing a web service with Docker and orchestrating it with Kubernetes for scalable deployment.
View SKILL.md on GitHub

Documentation & Knowledge Sharing

Communicating the intended behavior and context of code through clear documentation and comments, and sharing knowledge with the team.

Key guidelines
  • Comment for Clarity: Add explanatory comments where code isn’t self-explanatory – for example, to clarify complex algorithms, workarounds, or important decisions. A brief comment can save others (and your future self) lots of time understanding the code’s intent.
  • Keep Docs Up-to-Date: Treat documentation as a living part of the code. Whenever code behavior changes, update relevant comments and docs accordingly. This prevents misleading information. Inline code comments should always reflect the current state of the code.
  • Project Documentation: Adhere to your project’s documentation standards for things like API docs, developer guides, or maintainers lists. For instance, if contributing to an open-source project, ensure files like OWNERS are updated properly to reflect component maintainers. Proper docs ensure transparency and smooth knowledge transfer.
Example scenarios
  • Writing a README for a project that explains how to set it up and the overall architecture.
  • Adding a comment in code to clarify why a workaround is used, or marking a section as deprecated with explanation.
View SKILL.md on GitHub

Full-Stack Development

Ability to develop both front-end and back-end systems, integrating user interfaces with server logic and databases.

Key guidelines
  • Front & Back Proficiency: Build competency in both front-end (e.g. React or other JS frameworks) and back-end (e.g. Node.js, Python, Java) development. Most developers today are expected to span both areas in a full-stack capacity.
  • Unified Tech Stack: Leverage technologies that allow sharing code or language between client and server. For example, using Node.js for server-side enables using JavaScript/TypeScript in both front-end and back-end, allowing real-time, scalable applications with a single language.
  • Integrate Databases & APIs: Be comfortable designing database schemas and building RESTful or GraphQL APIs. Full-stack work often involves linking the UI to persistent storage and external services, requiring knowledge of SQL/NoSQL databases and API design best practices.
Example scenarios
  • Creating a web application with a React (front-end) and Node.js/Express (back-end) stack.
  • Designing an API server and the accompanying front-end interface that consumes it.
View SKILL.md on GitHub

Secure Coding Practices

Incorporating security at every step of software development – writing code that defends against vulnerabilities and protects user data.

Key guidelines
  • Follow Security Best Practices: Adhere to well-known secure coding standards like the OWASP Top 10. Validate inputs, use proper authentication and error handling, and keep dependencies up to date to patch known vulnerabilities. These habits prevent common exploits.
  • DevSecOps Mindset: Integrate security checks into development. Perform code reviews and use automated tools (scanners, dependency checks) to catch flaws early. For example, run static analysis to detect insecure code patterns before they reach production.
  • Cloud & API Security: Be aware of security for the platforms you use. Protect cloud infrastructure with appropriate configurations and services and secure your APIs with authentication, authorization, and rate-limiting. Understanding cloud security is now essential for developers, not just dedicated security teams.
Example scenarios
  • Validating all inputs and encoding outputs to prevent injection attacks (SQL injection, XSS, etc.).
  • Using secure libraries and protocols (HTTPS, OAuth) and storing sensitive data (passwords, API keys) in encrypted form or secret managers.
View SKILL.md on GitHub

Testing & Debugging

Ensuring software correctness and reliability by writing automated tests, using quality assurance tools, and systematically debugging issues.

Key guidelines
  • Automated Testing: Write tests to cover your code’s behavior – unit tests for individual functions, integration tests for components, etc. Aim for meaningful coverage of critical paths and edge cases. This ensures your code is correct and stays correct as it evolves.
  • Quality Tools: Employ linters and formatters to catch issues and enforce standards automatically. For example, use ESLint or Prettier so style issues are fixed upfront, freeing code reviews to focus on logic. Use static analysis and security scanners to find flaws early.
  • Systematic Debugging: When bugs arise, debug methodically. Reproduce issues in a controlled environment, use breakpoints or logging to inspect state, and bisect changes if necessary. Once fixed, add tests for those cases to avoid regressions. A disciplined debugging approach saves time and builds more reliable software.
Example scenarios
  • Implementing a suite of unit tests for each new feature, and running them in a CI pipeline on each commit.
  • Using a debugger or logging to track down the root cause of a bug, then adding a test to prevent regression.
View SKILL.md on GitHub

Guided learning paths

Short sequences that bundle multiple tutorials so you can go from discovery to automation without missing a step.

Start here

Reviewer onboarding

  1. Browse reviewers: Filter by language and focus, then bookmark the prompts that match your repo.
  2. Run the prompt locally: Paste into your editor or agent and test against a known PR.
  3. Tune heuristics: Capture new notes, edge cases, or QA tips in your fork for teammates.
Start browsing reviewers
Level up

Claude Skills workflow

  1. Install the CLI: Fetch dependencies and run tools/awesome2claude.py --help.
  2. Generate skills: Export individual reviewers or combined skills tailored to your project.
  3. Connect to Claude: Load the SKILL.md bundle in Workflows or the desktop app.
Use the CLI walkthrough
Advanced

Automation and reporting

  1. Design your trigger: Decide when reviewers or skills should run (push, nightly, security scans).
  2. Store results: Capture generated findings in GitHub Checks, Slack, or your incident tracker.
  3. Iterate with telemetry: Feed back real failures into custom reviewer variants.
Read the automation practices

Additional resources

Keep sharpening your reviewer stack with live data, community contributions, and deep dives into how prompts evolve.

  • Leaderboard: Track who contributes fresh reviewers and see emerging specialities.
  • Organizations: Find prompts sourced from projects that mirror your stack.
  • Methodology: Understand the data pipeline that powers every reviewer and skill export.

Ready to learn by doing?

Pair the tutorials with the reviewer library to ship faster PRs, healthier automations, and reusable Claude Skills.

Choose your reviewer Generate a skill bundle Explore the toolchain