sethdford/claude-skills - Page 9

automated-review-setup

Set up automated code review tools (linters, SAST, dependency scanning) to reduce manual review burden. Use when configuring CI/CD toolchains.

code-review-standards

Establish clear, enforceable code review standards that balance quality with velocity, enabling asynchronous review and knowledge sharing. Use when creating or updating review expectations, scaling engineering teams, or improving code quality metrics.

constructive-feedback

Provide code review feedback that improves code and team culture. Use when training reviewers or giving feedback guidelines.

merge-strategy

Define merge strategies (squash, rebase, merge commits) that balance history clarity with practical workflow. Use when setting CI/CD merge policies.

quality-gate-definition

Define automated quality gates that enforce standards without manual review. Use when setting up CI/CD checks and blocking criteria.

review-checklist-design

Design effective review checklists that surface defects without slowing teams down. Use when creating domain-specific review criteria.

review-culture-guide

Build a review culture where feedback improves code and team relationships. Use when establishing review norms and psychological safety.

review-metrics

Track code review health metrics (cycle time, review participation, defect escape) to improve review process. Use when analyzing review effectiveness.

alignment-facilitation

Facilitate alignment sessions when teams have different visions or priorities. Use before major initiatives or when resolving cross-functional conflict.

cross-team-coordination

Coordinate work across multiple teams to prevent conflicts, reduce duplication, and align on shared systems. Use when scaling beyond single team or managing dependencies.

design-engineering-handoff

Create design-to-engineering handoff processes that minimize rework and ensure designs are implementable. Use when coordinating with design teams or establishing design-engineering collaboration.

scope-negotiation

Negotiate scope defensively when timelines are tight or requirements are vague. Use when facing unrealistic deadlines or unclear feature requests.

stakeholder-communication

Communicate technical progress, tradeoffs, and risks to non-engineers in language they understand. Use in status updates, executive presentations, or crisis communication.

technical-product-partnership

Build collaborative relationships with product managers where engineers shape strategy and product makes informed decisions about technical tradeoffs. Use when coordinating feature prioritization or platform decisions.

technical-requirements-translation

Translate business/user requirements into technical specifications that engineers can build against. Use when clarifying ambiguous requirements or discovering hidden technical constraints.

accessibility-standards

Establish accessibility standards that make products usable for people with disabilities without being an afterthought. Use when building user-facing systems or scaling the product.

coding-standards

Define and enforce coding standards that reduce cognitive load, prevent bugs, and make code maintainable. Use when establishing style guides or linting rules.

developer-experience-audit

Systematically assess and improve developer experience (tools, documentation, onboarding, debugging) to increase team productivity. Use in roadmapping or when noticing developer friction.

documentation-standards

Establish documentation standards that keep docs current, discoverable, and useful. Use when scaling team or improving knowledge retention.

monitoring-strategy

Design monitoring and alerting that catches production issues fast without creating alert fatigue. Use when establishing observability or improving incident response.

security-practices

Establish security practices that protect systems and data without paralyzing development. Use when scaling security or responding to threats.

testing-strategy

Design testing strategies (unit, integration, end-to-end, performance) that catch bugs without creating bottlenecks. Use when scaling testing or improving release confidence.

tooling-strategy

Plan tooling investments that multiply team productivity (CI/CD, linters, debuggers, profilers, test frameworks). Use in roadmapping or when choosing development tools.

branching-strategy

Design branching strategies (git flow, trunk-based development, etc.) that support parallel work while maintaining stability. Use when establishing version control discipline or managing deployment complexity.

change-management

Design change control processes that prevent production surprises while avoiding process paralysis. Use when coordinating multiple team changes or managing infrastructure modifications.

definition-of-ready

Define criteria for work to enter development (DoR) to ensure engineering time is spent on well-understood, achievable work. Use when standardizing requirements or reducing rework.

development-workflow

Design development workflows that balance speed, quality, and safety. Use when establishing team processes or improving delivery efficiency.

incident-management-process

Design incident response procedures that prioritize quick resolution and learning over blame. Use when establishing on-call practices or improving incident response effectiveness.

on-call-rotation

Design fair on-call schedules that distribute burden, prevent burnout, and maintain coverage. Use when establishing on-call practices or scaling incident response.

process-improvement

Systematically identify and implement process improvements that increase team velocity and reduce friction. Use in retrospectives or when noticing repeated friction points.

release-management

Design repeatable release processes that minimize risk and manual overhead. Use when shipping to production, managing versioning, or coordinating multi-team releases.

career-ladder-design

Create transparent role progression frameworks showing how engineers advance within technical and lateral tracks. Use when defining career paths and promotion criteria.

knowledge-sharing-plan

Design systematic knowledge transfer mechanisms (lunch-and-learns, brown bags, wikis, architecture reviews) to prevent silos. Use when scaling team or protecting against key person risks.

mentoring-plan

Structure intentional mentoring relationships with clear goals and growth pathways. Use when developing junior engineers or enabling career growth in your team.

onboarding-program

Design structured onboarding that accelerates new hire productivity and reduces time-to-contribution. Use when bringing on engineers at any level or scaling the team.

one-on-one-template

Structure effective one-on-one meetings that build trust, surface concerns, and align on growth and development. Use when preparing regular 1:1s with direct reports or designing 1:1 practices for your team.

pair-programming-facilitation

Structure effective pair programming sessions for learning, code quality, and knowledge transfer. Use when onboarding, tackling high-risk work, or mentoring through complex problems.

performance-feedback

Deliver feedback that builds confidence, corrects course, and accelerates growth. Use in 1:1s, code reviews, and performance cycles.

skill-matrix

Map team capabilities against current and future role requirements. Use when planning capacity, identifying training needs, or succession planning.

engineering-blog-post

Write technical blog posts that document decisions, share learnings, and build external reputation. Use for knowledge sharing, hiring, and credibility building.