petekp-agent-skills

First-principles simplification analysis for codebases. Inventories what code actually does, then assesses whether the implementation is the simplest way to achieve it.

Craft a high-quality prompt for a deep research agent (like ChatGPT Deep Research) through adaptive interviewing. Turns vague research needs into precise, comprehensive prompts that get dramatically better results.

Execute architectural refactoring from an assessment document with deterministic, chunked operations and aggressive verification at every step. Designed to prevent agent drift across sessions and context compactions.

Build a compilable type-level skeleton from a high-level architecture spec before writing any implementation logic. Proves architecture soundness via compiler verification before migration begins.

Create a narrative guide to a codebase or feature in the style of Knuth's Literate Programming — code and prose interwoven as an essay, ordered for human understanding

Continuous formal verification of architectural constraints, behavioral invariants, and code elegance for agent-driven codebases

Remove LLM-isms and AI writing patterns from text to restore natural human voice

Systematically identify and remove dead code, redundant implementations, and orphaned artifacts in agent-maintained codebases

Guided Shape Up workflow for taking projects from idea to working software. Orchestrates shaping and breadboarding through Frame, Shape, Breadboard, Slice, Build phases.

Make application behavior visible to coding agents by exposing structured logs and telemetry endpoints. Guides adding structured logging, exposing logs for agent access, and documenting how to query them.

Create a comprehensive review package of your current work to hand off to another LLM for code review, architecture review, or both

Generate a pedagogically-grounded study guide for learning an unfamiliar codebase using evidence-based learning techniques

Write changelog entries for open source documentation sites using Keep a Changelog format by reviewing git commits since the last entry

Transform a codebase study guide into a polished interactive web experience with scroll-driven storytelling, interactive architecture diagrams, and animated code walkthroughs

Ruthlessly analyze architectural seams to expose coupling problems, abstraction leaks, and design failures. Produces uncompromising redesign proposals that prioritize correctness over backwards compatibility.

Generate a smart bootstrap prompt to continue the current conversation in a fresh session from where you left off

Research a UI design aesthetic (brutalist, glassmorphism, cyberpunk, Apple HIG, neumorphism, Swiss modernist, Material Design, art deco, vaporwave, etc.) and produce exhaustive, implementation-ready design guidelines with exact CSS values, color palettes, component states, animations, and typography

Cold, methodical diagnostician for when you're stuck in agent-assisted app development. Diagnoses agent loops, architectural rot, environment corruption, and requirements drift, then intervenes precisely to unblock you.

Identify non-obvious signals, hidden patterns, and clever correlations in datasets using investigative data analysis techniques. Pairs with personality-profiler for enhanced signal extraction.

Product analytics expert using PostHog MCP. Surface insights, create dashboards, analyze funnels, track metrics, set up experiments, and understand user behavior with persistent product context.

Create high-quality animated explainer visuals for essays and blog posts. Use when visualizing concepts, processes, data, or ideas with interactive web animations. Outputs self-contained HTML/CSS/JS.

CAVEMAN HUNT BAD PROCESS! Me find greedy creature eating fire (CPU) and rocks (memory). Me bonk them. Lightning rock (battery) happy. Tribe proud.

Synthesize outputs from multiple AI models into a verified assessment by cross-referencing claims against actual source code to resolve contradictions and produce a more reliable document than any single model

Build interactive debugging interfaces that reveal internal system behavior through visualization. Use for state machines, data flow, events, algorithms, render cycles, animations, or any mechanism with hidden internals.

Expertise in architecting, implementing, reviewing, and debugging hierarchical matching systems including two-sided matching (Gale-Shapley), assignment/optimization (Hungarian algorithm), multi-level hierarchy matching, and entity resolution across hierarchies.

Interview-driven blog post drafting for technical product audiences. Use when user wants to write a blog post, article, or essay and needs help developing their thesis, structure, and initial draft. Triggers on "write a blog post", "draft an article", "help me write about X", "blog drafter", or when user has a topic they want to turn into written content. Conducts structured interviews using AskUserQuestion to extract the user's unique insights before generating drafts.

Conduct exhaustive, citation-rich research on any topic using all available tools: web search, browser automation, documentation APIs, and codebase exploration. Prioritizes accuracy over speed, cross-references claims across sources, identifies conflicts, and provides full citations with confidence levels.

Facilitate methodical review of proposals by chunking content, predicting reviewer reactions, and producing feedback adapted to the proposal's format

Enter todo recording mode to capture ideas without acting on them, then organize and prioritize on exit

Evaluate and optimize agent documentation in dotfiles (.claude, .codex, .cursor, .aider) for better discoverability and retrieval efficiency

Systematic audit methodology for rooting out bugs, race conditions, stale docs, and correctness issues. Use for code audits, reviewing agent-written code, or deep analysis of any system.

Meta-cognitive decision support that analyzes context and surfaces intelligent next-step options via AskUserQuestion with recommendations

writing (and

Compile agent-optimized changelog by cross-referencing git history with plans and documentation to identify key decisions and stale information

Guide users step-by-step through manually testing current work with selectable outcome options

Robust Rust patterns for file-backed data, parsing, persistence, FFI boundaries, and system integration

Create bespoke parameter tuning panels for iterating on animations, layouts, colors, typography, physics, or any visual parameters

Expert Unix and macOS systems engineer for shell scripting, system administration, command-line tools, launchd, Homebrew, networking, and low-level system tasks

Design and build native macOS applications with SwiftUI or AppKit following Apple's design guidelines and Liquid Glass design system

Apply Model-First Reasoning (MFR) to code generation tasks with formal modeling before implementation

Apply interaction design principles for intuitive, responsive interfaces including micro-interactions, loading states, transitions, and accessibility patterns

Capture learnings from sessions to project knowledge files or skills for cross-project reuse

Start development servers with intelligent port management, conflict resolution, and automatic browser opening

Apply professional typography principles for readable, hierarchical, and aesthetically refined interfaces

Assess a codebase's readiness for autonomous agent development and provide tailored recommendations

Write clear, plain-spoken code comments and documentation optimized for both human readers and AI coding assistants