ftitos-claude-code

Unified brain interface — routes queries to GBrain (people/decisions), Graphify (concepts/research), GitNexus (code structure/impact), or Engram (session memory/learnings)

Deprecated - use the superpowers:brainstorming skill instead

Incrementally fix build and type errors with minimal, safe changes.

Comprehensive security and quality review of uncommitted changes:

Deprecated - use the superpowers:executing-plans skill instead

Restate requirements, assess risks, and create step-by-step implementation plan. WAIT for user CONFIRM before touching any code.

Initialize a project with all integrated frameworks -- BASE + PAUL + Aegis + CARL in one command

Integrated review pipeline -- code review + security + Aegis + CARL decision logging in one command

Ship with full validation -- review gate check + tests + commit + BASE state update + CARL log

Advance the sprint phase with guidance and gating -- VALIDATE -> PLAN -> BUILD -> REVIEW -> TEST -> SHIP -> MONITOR

Unified status dashboard across all frameworks -- BASE + PAUL + Aegis + CARL + Sprint

Enforce test-driven development workflow. Scaffold interfaces, generate tests FIRST, then implement minimal code to pass. Ensure 80%+ coverage.

Run comprehensive verification on current codebase state.

Deprecated - use the superpowers:writing-plans skill instead

Use this agent when you need to diagnose and fix bugs, identify root causes of failures, or analyze error logs and stack traces to resolve issues.

Documentation and codemap specialist. Use PROACTIVELY for updating codemaps and documentation. Generates docs/CODEMAPS/*, updates READMEs and guides.

Use when adding, modifying, or debugging an anti-pattern detection rule in this repo. Walks through the TDD recipe, the rule schema, all five plug-in points, jsdom constraints, and the post-implementation checklist. Trigger this for any work touching src/detect-antipatterns.mjs, tests/fixtures/antipatterns/, or extension/detector/.

Software architecture specialist for system design, scalability, and technical decision-making. Use PROACTIVELY when planning new features, refactoring large systems, or making architectural decisions.

Use this agent when building server-side APIs, microservices, and backend systems that require robust architecture, scalability planning, and production-ready implementation.

Build and TypeScript error resolution specialist. Use PROACTIVELY when build fails or type errors occur. Fixes build/type errors only with minimal diffs, no architectural edits. Focuses on getting the build green quickly.

Expert code review specialist. Proactively reviews code for quality, security, and maintainability. Use immediately after writing or modifying code. MUST BE USED for all code changes.

Validates features and architectural decisions against project principles before implementation begins. Returns APPROVED / APPROVED WITH CONDITIONS / NEEDS REVISION / REJECTED.

Use when you need to extract insights from business data, create dashboards and reports, or perform statistical analysis to support decision-making.

End-to-end testing specialist using Playwright. Use PROACTIVELY for generating, maintaining, and running E2E tests. Manages test journeys, quarantines flaky tests, uploads artifacts (screenshots, videos, traces), and ensures critical user flows work.

Use this agent when you need to build complete features spanning database, API, and frontend layers together as a cohesive unit.

Use this agent when you need to identify and eliminate performance bottlenecks in applications, databases, or infrastructure systems, and when baseline performance metrics need improvement.

Expert planning specialist for complex features and refactoring. Use PROACTIVELY when users request feature implementation, architectural changes, or complex refactoring. Automatically activated for planning tasks.

Holistic product leader who owns the full product lifecycle — from discovery and strategy through roadmap, stakeholder alignment, go-to-market, and outcome measurement. Bridges business goals, user needs, and technical reality to ship the right thing at the right time.

Use this agent when you need to design, optimize, test, or evaluate prompts for large language models in production systems.

Expert Python code reviewer specializing in PEP 8 compliance, Pythonic idioms, type hints, security, and performance. Use for all Python code changes. MUST BE USED for Python projects.

Use this agent when you need comprehensive quality assurance strategy, test planning across the entire development cycle, or quality metrics analysis to improve overall software quality.

Dead code cleanup and consolidation specialist. Use PROACTIVELY for removing unused code, duplicates, and refactoring. Runs analysis tools (knip, depcheck, ts-prune) to identify dead code and safely removes it.

Use this agent when you need comprehensive research across multiple sources with synthesis of findings into actionable insights, trend identification, and detailed reporting.

Security vulnerability detection and remediation specialist. Use PROACTIVELY after writing code that handles user input, authentication, API endpoints, or sensitive data. Flags secrets, SSRF, injection, unsafe crypto, and OWASP Top 10 vulnerabilities.

Test-Driven Development specialist enforcing write-tests-first methodology. Use PROACTIVELY when writing new features, fixing bugs, or refactoring code. Ensures 80%+ test coverage.

Design and optimize AI agent action spaces, tool definitions, and observation formatting for higher completion rates.

Operate as an agentic engineer using eval-first execution, decomposition, and cost-aware model routing.

Engineering operating model for teams where AI agents generate a large share of implementation output.

Regression testing strategies for AI-assisted development. Catch systematic blind spots where the same model writes and reviews code.

REST API design patterns including resource naming, status codes, pagination, filtering, error responses, versioning, and rate limiting for production APIs.

Transform Claude Code into a fully autonomous agent system with persistent memory, scheduled operations, and task queuing.

Patterns and architectures for autonomous Claude Code loops -- from simple sequential pipelines to RFC-driven multi-agent DAG systems.

Backend architecture patterns, API design, database optimization, and server-side best practices for Node.js, Express, and Next.js API routes.

Use before any creative work -- creating features, building components, adding functionality. Explores user intent, requirements, and design before implementation.

Automate visual testing and UI interaction verification using browser automation after deploying features.

Raw mechanical interfaces fusing Swiss typographic print with military terminal aesthetics. Rigid grids, extreme type scale contrast, utilitarian color, analog degradation effects. For data-heavy dashboards, portfolios, or editorial sites that need to feel like declassified blueprints.

Monitor a deployed URL for regressions after deploys, merges, or dependency upgrades.

AI-powered code review patterns. Use when reviewing code changes, checking code quality, finding bugs or security issues, or running fix-review cycles.

Simplifies code for clarity. Use when refactoring code for clarity without changing behavior. Use when code works but is harder to read, maintain, or extend than it should be. Use when reviewing code that has accumulated unnecessary complexity.

Analyze an unfamiliar codebase and generate a structured onboarding guide with architecture map, key entry points, conventions, and a starter CLAUDE.md.

Universal coding standards, best practices, and patterns for TypeScript, JavaScript, React, and Node.js development.

Audits Claude Code context window consumption across agents, skills, MCP servers, and rules. Identifies bloat, redundant components, and produces prioritized token-savings recommendations.

Optimizes agent context setup. Use when starting a new session, when agent output quality degrades, when switching between tasks, or when you need to configure rules files and context for a project.

Instinct-based learning system that observes sessions via hooks, creates atomic instincts with confidence scoring, and evolves them into skills/commands/agents.

Cost optimization patterns for LLM API usage -- model routing by task complexity, budget tracking, retry logic, and prompt caching.

Database migration best practices for schema changes, data migrations, rollbacks, and zero-downtime deployments across PostgreSQL and common ORMs.

Guides systematic root-cause debugging. Use when tests fail, builds break, behavior doesn't match expectations, or you encounter any unexpected error. Use when you need a systematic approach to finding and fixing the root cause rather than guessing.

Multi-source deep research using web search tools. Searches the web, synthesizes findings, and delivers cited reports with source attribution.

Deployment workflows, CI/CD pipeline patterns, Docker containerization, health checks, rollback strategies, and production readiness checklists.

Use when facing 2+ independent tasks that can be worked on without shared state or sequential dependencies.

Django architecture patterns, REST API design with DRF, ORM best practices, caching, signals, middleware, and production-grade Django apps.

Docker and Docker Compose patterns for local development, container security, networking, volume strategies, and multi-service orchestration.

Playwright E2E testing patterns, Page Object Model, configuration, CI/CD integration, artifact management, and flaky test strategies.

Formal evaluation framework for Claude Code sessions implementing eval-driven development (EDD) principles.

Use when you have a written implementation plan to execute in a separate session with review checkpoints

Use when implementation is complete, all tests pass, and you need to decide how to integrate the work - guides completion of development work by presenting structured options for merge, PR, or cleanup

Frontend development patterns for React, Next.js, state management, performance optimization, and UI best practices.

Git workflow patterns including branching strategies, commit conventions, merge vs rebase, conflict resolution, and collaborative development best practices.

Design, implement, and refactor Ports & Adapters systems with clear domain boundaries, dependency inversion, and testable use-case orchestration.

Refines ideas iteratively. Refine ideas through structured divergent and convergent thinking. Use "idea-refine" or "ideate" to trigger.

Elite website image-to-code skill for Codex. For visually important web tasks, it must first generate the design image(s) itself, deeply analyze them, then implement the website to match them as closely as possible. In Codex, it must prefer large, readable, section-specific images instead of tiny compressed boards, generate fresh standalone images for sections or detail views instead of cropping old ones, avoid lazy under-generation, avoid cards-inside-cards-inside-cards UI, and keep the hero clean, spacious, readable, and visible on a small laptop.

Use when the user wants to design, redesign, shape, critique, audit, polish, clarify, distill, harden, optimize, adapt, animate, colorize, extract, or otherwise improve a frontend interface. Covers websites, landing pages, dashboards, product UI, app shells, components, forms, settings, onboarding, and empty states. Handles UX review, visual hierarchy, information architecture, cognitive load, accessibility, performance, responsive behavior, theming, anti-patterns, typography, fonts, spacing, layout, alignment, color, motion, micro-interactions, UX copy, error states, edge cases, i18n, and reusable design systems or tokens. Also use for bland designs that need to become bolder or more delightful, loud designs that should become quieter, live browser iteration on UI elements, or ambitious visual effects that should feel technically extraordinary. Not for backend-only or non-UI tasks.

Delivers changes incrementally. Use when implementing any feature or change that touches more than one file. Use when you're about to write a large amount of code at once, or when a task feels too big to land in one step.

Triage GitHub issues — classify severity, assign labels, identify duplicates, and route to the right owner. Use when a backlog needs prioritizing or a new issue needs categorization.

Comprehensive markdown and Mermaid diagram writing skill. Text-based diagrams as the default documentation standard with style guides and diagram type references.

Build MCP servers with Node/TypeScript SDK -- tools, resources, prompts, Zod validation, stdio vs Streamable HTTP.

Clean editorial-style interfaces. Warm monochrome palette, typographic contrast, flat bento grids, muted pastels. No gradients, no heavy shadows.

Overrides default LLM truncation behavior. Enforces complete code generation, bans placeholder patterns, and handles token-limit splits cleanly. Apply to any task requiring exhaustive, unabridged output.

Triage open pull requests — assess review readiness, flag stale PRs, check for merge conflicts, and route to reviewers. Use during sprint sync or before a release cut.

Validate the "why" before building. Run product diagnostics and convert vague ideas into specs. Includes forcing questions, founder review, user journey audit, and feature prioritization.

Pythonic idioms, PEP 8 standards, type hints, and best practices for building robust, efficient, and maintainable Python applications.

Python testing strategies using pytest, TDD methodology, fixtures, mocking, parametrization, and coverage requirements.

Use when receiving code review feedback, before implementing suggestions, especially if feedback seems unclear or technically questionable - requires technical rigor and verification, not performative agreement or blind implementation

Upgrades existing websites and apps to premium quality. Audits current design, identifies generic AI patterns, and applies high-end design standards without breaking functionality. Works with any CSS framework or vanilla CSS.

Generate a concise recap of recent repository activity — commits, PRs merged, issues closed, and open blockers. Use for standups, sprint reviews, or onboarding new contributors.

Use when completing tasks, implementing major features, or before merging to verify work meets requirements

Research-before-coding workflow. Search for existing tools, libraries, and patterns before writing custom code.

Use this skill when adding authentication, handling user input, working with secrets, creating API endpoints, or implementing payment/sensitive features. Provides comprehensive security checklist and patterns.

Measures whether skills, rules, and agent definitions are actually followed by auto-generating scenarios, running agents, and reporting compliance rates.

Teaches the AI to design like a high-end agency. Defines the exact fonts, spacing, shadows, card structures, and animations that make a website feel expensive. Blocks all the common defaults that make AI designs look cheap or generic.

Grounds every implementation decision in official documentation. Use when you want authoritative, source-cited code free from outdated patterns. Use when building with any framework or library where correctness matters.

Creates specs before coding. Use when starting a new project, feature, or significant change and no specification exists yet. Use when requirements are unclear, ambiguous, or only exist as a vague idea.

Semantic Design System Skill for Google Stitch. Generates agent-friendly DESIGN.md files that enforce premium, anti-generic UI standards — strict typography, calibrated color, asymmetric layouts, perpetual micro-motion, and hardware-accelerated performance.

Suggests manual context compaction at logical intervals to preserve context through task phases rather than arbitrary auto-compaction.

Execute implementation plans by dispatching a fresh subagent per task, with two-stage review (spec compliance then code quality) after each.

Senior UI/UX Engineer. Architect digital interfaces overriding default LLM biases. Enforces metric-based rules, strict component architecture, CSS hardware acceleration, and balanced design engineering.

Use this skill when writing new features, fixing bugs, or refactoring code. Enforces test-driven development with 80%+ coverage including unit, integration, and E2E tests.

UI/UX design intelligence for web and mobile. Includes 50+ styles, 161 color palettes, 57 font pairings, 161 product types, 99 UX guidelines, and 25 chart types across 10 stacks (React, Next.js, Vue, Svelte, SwiftUI, React Native, Flutter, Tailwind, shadcn/ui, and HTML/CSS). Actions: plan, build, create, design, implement, review, fix, improve, optimize, enhance, refactor, and check UI/UX code. Projects: website, landing page, dashboard, admin panel, e-commerce, SaaS, portfolio, blog, and mobile app. Elements: button, modal, navbar, sidebar, card, table, form, and chart. Styles: glassmorphism, claymorphism, minimalism, brutalism, neumorphism, bento grid, dark mode, responsive, skeuomorphism, and flat design. Topics: color systems, accessibility, animation, layout, typography, font pairing, spacing, interaction states, shadow, and gradient. Integrations: shadcn/ui MCP for component search and examples.

Use when starting feature work that needs isolation from current workspace or before executing implementation plans - creates isolated git worktrees with smart directory selection and safety verification

A comprehensive verification system for Claude Code sessions.

Use when you have a spec or requirements for a multi-step task, before touching code

Use when creating new skills, editing existing skills, or verifying skills work before deployment

14 hooks across 7 events

Up-to-date library documentation and code examples

Persistent knowledge graph for cross-session memory

Multi-step reasoning and problem decomposition

Browser automation for E2E testing and visual QA

GitHub repository documentation explorer

WHO+WHY engine — people, companies, decisions

WHAT+HOW engine — concepts, research, Obsidian integration

WHERE+IMPACT engine — code structure, blast radius, knowledge graph

LEARNED engine — session memory, observations, learnings