personal-agent-skills

MCP server design, development, and audit using the Python SDK (FastMCP). Use when: creating a new MCP server, wrapping an API as MCP tools, auditing an existing MCP server for patterns and gaps, adding auth/secrets/retry/observability to an MCP server, choosing between tools vs resources vs prompts, designing MCP resources or resource templates, creating MCP prompts for workflow bootstrapping, choosing between low-level Server and FastMCP, designing tool contracts, configuring pydantic-settings, adding structured logging, writing MCP server tests, or improving an existing MCP server codebase.

Writing for specific audiences: leadership, peers, team, and org-wide. Use when: preparing an executive briefing, writing a team newsletter, communicating up/down/ laterally, announcing a launch or change, escalating an issue, delivering difficult messages, pushing back on a request, or building team visibility across the org.

OKRs and contribution goals — writing, cascading, scoring, and individual goal setting. Use when: setting team OKRs, writing individual contribution goals, cascading company OKRs to team level, coaching someone on goal quality, preparing for OKR reviews, scoring OKRs at end of cycle, or linking contribution goals to team OKRs. Covers both team-level OKRs and individual contribution goal frameworks.

Presentation design, outlining, visual best practices, and brand compliance. Use when: building a presentation outline, choosing visuals for a slide deck, structuring a talk for a specific audience, iterating on presentation content in markdown before graduating to slides, reviewing an existing deck for flow and clarity, selecting the right chart or diagram type for a given message, or ensuring slides comply with an organization's brand guide.

Communicating effectively up, down, and laterally within an org chart. Use when: preparing an executive briefing, presenting to leadership, managing stakeholder expectations, negotiating priorities with product or peer teams, escalating issues, delivering difficult messages, or building influence without authority.

Writing clear, actionable tickets in any issue tracker (Jira, Linear, GitHub Issues, ServiceNow, etc.). Use when: creating epics, stories, tasks, bugs, or spikes; writing acceptance criteria; decomposing work for a sprint; linking dependencies between tickets; auditing backlog items for clarity; or coaching a team on ticket quality. Covers title conventions, description templates, acceptance criteria, decomposition rules, dependency linking, and org-specific pluggable configuration.

>-

Rigorous critical analysis of designs, strategies, communications, and proposals. Use when: stress-testing a design or architecture, playing devil's advocate on a strategy, poking holes in assumptions, evaluating competing arguments, challenging a proposal before it ships, reviewing a communication for logical weaknesses, pressure-testing a plan before presenting to leadership, or when someone asks "what am I missing?" Works on any artifact: technical designs, business strategies, product proposals, org changes, communications, or process decisions.

Critically evaluate and improve an existing classification system or taxonomy. Use when: reviewing how items are grouped (code modules, document categories, data labels, skill folders, config buckets, CSV/JSON columns, API enums), challenging whether current groupings still serve their purpose, merging overlapping categories, splitting overloaded ones, renaming for clarity, or redistributing items to better align with downstream use cases. Works on any classifiable data: code, markdown, structured data (CSV, JSON), taxonomies, hierarchical systems, or free-form lists.

>-

CI/CD pipeline design with Harness Drone. Use when: creating .drone.yml pipelines, designing build/test/deploy stages, adding code coverage, publishing artifacts, configuring scheduled runs, applying CI/CD best practices, auditing existing pipelines for gaps, or improving pipeline efficiency and reliability. Covers linting gates, test parallelism, coverage thresholds, Docker image builds, secret management, and deployment strategies.

Data analysis workflows with pandas, Polars, and DuckDB for exploration, cleaning, and transformation. Use when: performing exploratory data analysis, cleaning messy datasets, computing aggregations and statistics, writing Jupyter/Marimo notebook workflows, choosing between pandas and Polars, querying Parquet files with DuckDB, building reproducible analysis notebooks, auditing existing analysis code for performance or correctness, or designing post-pipeline transform steps.

Database schema and data migration patterns for zero-downtime production deployments. Use when: writing SQL migrations, changing DynamoDB table structures, running data backfills, planning breaking schema changes, designing rollback strategies, auditing an existing project for migration risks, or coordinating database changes with application deployments. Covers expand-contract migrations, backward-compatible changes, data backfills, rollback plans, and migration testing.

Dependency evaluation, supply chain security, and maintenance for Python and JavaScript projects. Use when: evaluating whether to add a new dependency, comparing alternatives, pruning unused dependencies, auditing for vulnerabilities, configuring Renovate or Dependabot, managing lockfiles, checking license compliance, resolving version conflicts, remediating CVEs, or auditing an existing project for dependency hygiene. Covers the full lifecycle: evaluate → add → lock → audit → update → prune.

IDE configuration and extension management for VS Code, Cursor, and Claude Code. Use when: setting up a development environment, installing extensions, configuring Pylance for Python type checking, setting up Prettier and ESLint, integrating test runners, configuring Python environments with uv, auditing IDE settings for missing or inconsistent configuration, or ensuring consistent editor behavior across tools.

Product roadmapping, prioritization, and specification writing. Use when: building a product roadmap, prioritizing features using RICE or other frameworks, writing product requirements documents (PRDs), creating user stories, defining acceptance criteria, planning sprints or milestones, evaluating feature requests, making build vs buy decisions for product features, auditing an existing roadmap for focus, or writing product specs for engineering handoff.

Application security standards and hardening practices. Use when: reviewing code for vulnerabilities, implementing authentication, configuring CORS, adding input validation, managing secrets, scanning dependencies, setting CSP headers, reviewing IAM policies, auditing an existing application for OWASP top 10 vulnerabilities, or hardening an existing deployment. Covers OWASP top 10, secrets management, dependency auditing, and security headers.

Automated accessibility testing and WCAG compliance validation. Use when: adding accessibility tests to a project, configuring axe-core or pa11y, integrating a11y checks into CI, auditing an existing application for accessibility violations, validating ARIA usage, testing keyboard navigation, or building an accessibility regression suite. Covers axe-core, Playwright a11y testing, Lighthouse accessibility audits, CI integration, and WCAG 2.2 AA compliance.

REST API design conventions and contract standards. Use when: designing API endpoints, defining request/response schemas, implementing pagination, versioning APIs, creating OpenAPI specs, adding rate limiting, designing error responses, auditing existing APIs for REST convention compliance, or improving API consistency and documentation.

Error handling and resilience patterns for robust services. Use when: implementing retry logic, adding circuit breakers, configuring timeouts, designing graceful degradation, handling partial failures, building dead letter queues, classifying errors for retry decisions, implementing abort/cancellation patterns, designing cleanup registries, implementing graceful shutdown, auditing an existing service for missing error handling, or improving fault tolerance in distributed systems. Covers retry with backoff, circuit breakers, timeout strategies, error classification, abort signals, cleanup lifecycle, graceful shutdown, fallback patterns, and structured error propagation.

Feature flag design, lifecycle management, and progressive rollout strategies. Use when: adding feature toggles to gate new functionality, implementing gradual rollouts, designing A/B experiments, managing flag lifecycle and cleanup, auditing an existing codebase for stale flags, or choosing between flag implementations. Covers flag types, evaluation strategies, rollout patterns, flag hygiene, and testing with flags.

Release management with semantic versioning, changelogs, and release workflows. Use when: choosing version numbers, creating releases, writing release notes, writing changelogs, designing release branches, automating version bumps, tagging releases, defining release checklists, or deciding when to cut a release. Covers SemVer 2.0.0, pre-release versions, release notes with breaking/functional/non-functional tiers, release pipelines, and changelog automation.

OKR writing, cascading, scoring, and review cycles. Use when: setting team or individual OKRs, cascading company OKRs to team level, writing measurable key results, preparing for OKR reviews, scoring OKRs at end of cycle, coaching team members on effective OKR writing, or auditing existing OKRs for quality.

Sprint and quarterly retrospective facilitation. Use when: running a sprint retro, facilitating a quarterly retrospective, choosing retro formats, tracking action items from retros, identifying patterns across retros, or improving team retrospective culture. Covers facilitation techniques, formats, action tracking, and anti-patterns.

Annual and quarterly roadmap planning for engineering teams. Use when: building or updating a team roadmap, prioritizing initiatives, mapping dependencies across teams, preparing roadmap presentations for leadership, evaluating trade-offs between competing priorities, or aligning roadmap items to company strategy and OKRs.

Writing effective status updates for different audiences and cadences. Use when: writing a weekly status update, preparing a monthly summary, drafting a quarterly review, sending updates to leadership, sharing progress with stakeholders, or improving the clarity and impact of team communications. Covers weekly, monthly, and quarterly formats tailored for upward, lateral, and downward communication.

Generic framework for comparing alternatives and making structured decisions. Use when: evaluating competing options for architecture, strategy, tools, vendors, dependencies, pricing models, or process changes; auditing an existing decision for gaps; choosing between build vs buy approaches; or presenting a recommendation with explicit trade-offs and evidence.

Structured workflow for implementing a large or complex change. Use when: planning a significant feature, decomposing a multi-day refactor, introducing a breaking change, coordinating cross-cutting implementation work, or shipping a new subsystem with phased delivery and clear release criteria.

Code review practices and pull request quality standards. Use when: reviewing a pull request, preparing code for review, writing review comments, checking for common issues, establishing review guidelines, auditing an existing project's review practices, or improving PR quality standards. Integrates linting, testing, security, and CI/CD checks into a cohesive review workflow.

'Git commit, branching, and documentation conventions. Use when: writing commit messages, creating branches, preparing pull requests, reviewing changelogs, squashing commits, establishing git workflow standards, auditing commit history for convention compliance, or improving an existing project git workflow.'

Markdown documentation standards for developer-facing and project documentation. Use when: writing or auditing a README, creating project documentation, structuring a docs/ folder, documenting design decisions, writing ADRs, linking documents for discoverability, or ensuring an existing project has adequate developer documentation.

Testing strategy, patterns, and evaluation for software and LLM/AI systems. Use when: writing tests, choosing test boundaries, designing test data, structuring test suites, evaluating LLM outputs, building evaluation pipelines, setting coverage thresholds, auditing test coverage gaps in existing projects, or improving test quality and structure.

Event-driven architecture and asynchronous messaging patterns. Use when: designing pub/sub systems, implementing SQS/SNS/EventBridge workflows, building event-driven microservices, adding dead letter queues, designing message schemas, choosing between synchronous and asynchronous communication, auditing an existing system for messaging gaps, or implementing saga patterns. Covers AWS messaging services, message schema design, ordering guarantees, idempotency, error handling, and event sourcing.

Caching design across HTTP, CDN, application, and client layers. Use when: adding cache headers, configuring CloudFront or CDN behavior, implementing Redis or in-memory caching, designing IndexedDB or service worker caches, choosing cache invalidation strategies, auditing an existing application for missing or misconfigured caches, or optimizing API response times. Covers HTTP cache-control, CDN edge caching, application-level caching, client-side storage, cache invalidation patterns, and cache warming.

Data visualization and charting best practices. Use when: choosing a chart type for data, configuring axes, adding tooltips, implementing chart theming for dark mode, connecting chart colors to application design tokens, formatting axis tick values, making charts accessible, auditing existing charts for readability and accessibility, or improving chart consistency across an application.

Python data visualization for notebooks, scripts, and reports using matplotlib, seaborn, and Plotly. Use when: plotting analysis results in Jupyter/Marimo notebooks, choosing between static and interactive charts, creating publication- quality figures, building dashboard-style multi-panel layouts, exporting charts for reports or presentations, auditing existing plots for readability and accessibility, or improving visual consistency across an analysis project.

Database design conventions for DynamoDB single-table design and SQL/PostgreSQL. Use when: modeling access patterns, designing DynamoDB tables and GSIs, writing SQL migrations, configuring connection pools, optimizing queries, choosing between SQL and NoSQL, designing data models for serverless applications, auditing existing database schemas for performance or design issues, or improving query patterns and indexing.

Docker and container best practices with security-first, rootless design. Use when: writing Dockerfiles, building container images, creating docker-compose files, hardening containers, setting up local dev environments, configuring container registries, auditing existing Dockerfiles for security and size, or improving container build pipelines.

Structured logging and metrics design for analytics pipelines and dashboards. Use when: implementing application logging, designing log schemas, adding metrics collection, handling exception logging, building observability into services, integrating with log aggregation and dashboarding tools, auditing existing logging for structure and completeness, or improving observability in an existing service.

Best practices for writing, evaluating, and improving LLM prompts. Use when: writing system prompts, crafting user messages, designing few-shot examples, prompting for structured output, writing tool descriptions, designing RAG prompts, defending against prompt injection, auditing or improving existing prompts, building prompt templates, or evaluating prompt quality. Covers system prompt structure, chain-of-thought, few-shot patterns, token efficiency, tool calling prompts, multi-turn design, prompt security, and evaluation.