manutej

Comprehensive API gateway patterns skill covering Kong, routing, rate limiting, authentication, load balancing, traffic management, and production gateway architecture

Comprehensive API gateway patterns skill covering Kong, routing, rate limiting, authentication, load balancing, traffic management, and production gateway architecture

Container orchestration with Docker Compose for multi-container applications, networking, volumes, and production deployment

Container orchestration with Docker Compose for multi-container applications, networking, volumes, and production deployment

Modern Python API development with FastAPI covering async patterns, Pydantic validation, dependency injection, and production deployment

Modern Python API development with FastAPI covering async patterns, Pydantic validation, dependency injection, and production deployment

Comprehensive FastAPI skill for building modern Python web APIs with focus on customer support systems, ticket management, real-time chat, and backend operations

Comprehensive guide for building production-ready microservices with FastAPI including REST API patterns, async operations, dependency injection, and deployment strategies

Composable atomic blocks for categorical meta-prompting. Defines 16 reusable blocks across 4 layers (Assessment, Transformation, Refinement, Composition) that can be composed to build custom workflows. Enables progressive disclosure: simple commands work unchanged, power users can override individual blocks or compose freely.

Master reference for categorical meta-prompting unified syntax. Contains all modifiers, operators, composition patterns, and execution protocols. Use this skill for self-reference when executing any prompt workflow, ensuring consistent syntax across all commands and skills.

Dynamic prompt registry with unified categorical syntax. Supports @skills:discover(), @skills:compose(A⊗B), Reader monad for runtime lookup, and quality-tracked prompt libraries. Use for meta-prompts referencing sub-prompts, building prompt libraries, implementing deferred resolution, or composing templates dynamically.

Universal template for implementing categorical structures in meta-prompting frameworks. Applies to functors, monads, comonads, natural transformations, adjunctions, hom-equivalences, limits, colimits, and enriched categories. Use when extending frameworks with new categorical constructs.

Recursive Meta-Prompting (RMP) implementation with unified categorical syntax. Supports @mode:iterative, @quality: thresholds, >=> Kleisli composition, and comonadic context extraction. Use when implementing iterative prompt improvement, quality-gated generation loops, or applying categorical fixed-point semantics with convergence guarantees.

Full categorical framework for meta-prompting with verified laws. Use when implementing functor-based task routing, monadic iterative refinement, comonadic context extraction, or quality-tracked composition. Integrates F (Functor), M (Monad), W (Comonad), and [0,1]-enriched quality categories.

Systematic analysis patterns for categorical AI papers (Gavranović, de Wynter, Bradley, Zhang). Use when analyzing academic papers on categorical deep learning, extracting categorical structures from AI research, mapping meta-prompting concepts to category theory, or building comprehensive literature reviews on categorical approaches to AI.

Property-based testing for functor laws, monad laws, and naturality conditions using fp-ts and fast-check. Use when validating categorical implementations in TypeScript, testing algebraic laws in functional code, verifying functor/monad/applicative instances, or building test suites for categorical abstractions.

Complete guide for Apache Airflow orchestration including DAGs, operators, sensors, XComs, task dependencies, dynamic workflows, and production deployment

Low/high fidelity wireframes, user flows, information architecture, prototyping techniques, and design iteration processes

Complete guide for enterprise architecture patterns including domain-driven design, event sourcing, CQRS, saga patterns, API gateway, service mesh, and scalability

Comprehensive Angular framework development covering components, directives, services, dependency injection, routing, and reactive programming based on official Angular documentation

Modern React development with hooks, component patterns, state management, and performance optimization for building scalable applications

Mobile-first responsive design covering fluid layouts, media queries, flexbox, grid, viewport units, and responsive images

Comprehensive Svelte development skill covering reactivity runes, components, stores, lifecycle, transitions, and modern Svelte 5 patterns

Accelerate software development with Linear project management and MCP server integration. Master issue tracking, project workflows, and development automation for frontend, full-stack, and mobile applications. Includes comprehensive MCP tool usage, workflow patterns, and development best practices.

Makes schema, migration, and data-shape changes safe to ship. Use when writing a database migration, altering a table, adding/renaming/dropping a column, changing the shape of an API payload / event / serialized object, backfilling data, or reviewing any diff that touches persistent state. Catches one-shot breaking changes, NOT NULL without backfill, missing/untested rollbacks, nullability drift, and backfills that lock production tables. Enforces expand→migrate→ contract, one-deploy-window backward compatibility, and dry-run-on-a-copy evidence. Triggers: "write a migration", "alter table", "add a column", "rename this field", "change the schema", "is this migration safe", "change this response/event shape", "backfill".

Router and orchestrator for the craft code-quality guardrails. Use FIRST on any broad "is this production-ready?", "review this code/diff/PR", "build this properly", "why does our AI-generated code keep needing rework", or "make this maintainable" request. Two modes: GENERATIVE GUARD (load the right senior heuristics before writing code) and CRITIQUE (audit a diff/file and return one worst-first ranked list of findings). Decomposes the request, fires the relevant craft member skills plus the existing complexity/refactoring/dependency/test skills in the right order, resolves their conflicts, and returns a single merged verdict. Defer to a single member skill only when the task is already narrow.

Makes tests prove something and makes "done" mean done. Use when writing tests, judging existing tests, or before claiming a task is complete/production-ready. Catches tautological tests (asserting on their own mocks), tests that mirror the implementation, fake green CI, and the agent's habit of declaring victory without ever running the code. Enforces test-observable-behavior, the verification-before- done evidence gate, and characterization-tests-before-refactoring-untested-code. Triggers: "write tests for this", "are these tests any good", "is this done", "is it production-ready", "add coverage", before any "done"/handoff claim.

Detection lens for Fowler's five smell families — names the smell, states the change-cost, and hands the fix to `refactoring-patterns`. Use when reviewing a diff, auditing a module, or deciding whether to gate a merge. Triggers: "does this code have smells", "review for smells", "is this clean", "what's wrong with this design", "this class is getting big", "why is every change touching 12 files", "switch on type", "this method is too long", "is this AI slop".

Stops duplication and reinvention — the failure GitClear measures as "rework" (copy-paste up, refactoring down, the signature of AI code with a short shelf life). Use before writing any helper, util, type, constant, or component, and when reviewing a diff for repeated logic. Enforces search-before-build, consolidate- don't-clone, and DRY-as-knowledge (one rule, one authoritative place). Triggers: "is there already a function for this", "this looks duplicated", "DRY this up", "extract the common logic", "we keep rewriting this", before adding any utility.

Separates pure decision logic from I/O so code is testable without heavy mocks — without demanding religious purity. Use when a function both computes and writes to a DB, network, or log; when datetime.now()/random()/fetch() are called inline inside business logic; when a unit test needs five mocks to run; when reviewing code that tangles "what to do" with "do it." Triggers: "this is hard to test," "I need to mock the clock," "how do I test this without a DB," "pure function," "side effects," "functional core," "inject the dependency." NOT a trigger for: making everything pure, banning mutation, or wrapping simple code in monads.

Names and comments are the primary channel through which code communicates intent to the next engineer. Use when choosing an identifier ("what should I call this", "rename this", "is this name clear"), deciding whether to add a comment ("should I comment this", "does this need explaining"), or auditing existing prose ("clean up the comments", "too many comments", "comment slop"). Also fires when a name is hard to pick — that difficulty is a design smell, not a vocabulary problem (Ousterhout: Hard to Pick Name).

Fights over-engineering and premature abstraction — the #1 documented AI coding failure. Use when about to add a class, interface, factory, base-class, config layer, plugin system, generic "framework," or any abstraction; when a diff feels bigger than the request; or when reviewing code that has more structure than the problem warrants. Enforces smallest-diff-that-works, YAGNI, "no abstraction without 2-3 real call sites," and Ousterhout's deep-vs-shallow-module test. Triggers: "is this over-engineered", "simplify this", "do we need this abstraction", "this feels heavy", "make it production-ready" (often means add-robustness-not-structure).

Emits reader-specific account copy — outreach sequences, follow-ups, one-pagers, case-study atoms, QBR narratives, renewal and expansion notes — by selecting a typed sequence blueprint and filling its slots only with facts the account already holds, so every piece reads like it was written for one named reader and never like mail-merge. Use when the user says "outreach for [prospect]", "follow-up email", "nurture sequence", "one-pager", "case study", "QBR narrative", "renewal note", "win-back", "expansion copy", or when a factory contract includes 07-copy. Runs one reader or batches a whole list with per-reader verification. Every claim cites SYNTHESIS or is cut; refuses unpersonalizable sends and "just checking in" revivals.

Emits deal-specific bid paperwork from a typed clause system — proposal, contract skeleton, and internal pricing-floor math — by reading SYNTHESIS, computing a cost floor, selecting pricing shapes via a decision tree, and assembling plain-language clauses with bound slots. Use when the user says "write the bid", "proposal draft", "SOW", "contract for [prospect]", "pricing options", "redline their paper", or runs the 03-bid stage of a factory. Operates a level up from a document: a meta-prompt that generates paper, not a template. Never commits to volumes before proof; unknowns surface as flagged TBDs, never silent defaults; final terms always carry an attorney-review caveat.

Builds the touchable sample that enacts the buyer's own workflow step — an interactive single-file prototype, a ceti-method animated explainer, or a live-channel (phone/chat) demo — so the buyer experiences the offer instead of reading about it, with buildable per-form artifact specs and a rehearsed 3-minute run-of-show. Use when the user says "demo for [prospect]", "build the sample", "prototype they can touch", "demo plan", "show don't tell", or as the 04-demo stage of a factory run. A demo the buyer can call or click beats any document; a generic vertical demo demonstrates nothing.

Extracts a prospect's real brand palette from their public materials, harmonizes it into a WCAG 2.2 AA-audited token set, and fuses it with CETI house rigor so every deliverable feels already theirs. Emits design/tokens.css (the versioned sf-tokens schema every artifact skill consumes) and design/palette.md (provenance + contrast matrix). Use when the user says "design DNA for [company]", "extract their colors", "brand the deliverables for this prospect", "tokens for this client", or automatically as the design stage of any factory run before artifacts are built. Refuses to ship invented colors or failing contrast pairs.

Forges a new reusable deliverable FACTORY — a versioned, example-agnostic meta-prompt that serves every future instance of a recurring sales, copywriting, or account-material category, one abstraction level above any single deal. Use when the user says "forge a factory", "/forge", "new factory for X", "we keep making X for clients", "turn this into a standing pipeline", or names a recurring deliverable category (QBR packs, launch copy, onboarding kits, audit reports, renewal decks, partnership pitches). Also use to EDIT an existing factory after feedback — version bumps, slot additions, rule changes — and to run the generalization check on any factory edit. This is the meta-meta skill: it does not produce client artifacts; it mints the machine that produces them.

Hunts a prospect's provable weaknesses and buying tells from public sources and packages them as a typed, cited tells-dossier — the left half of the sign-here bijection (tells ↔ scope ↔ price) that makes the pitch feel painfully obvious. Use when the user says "hunt [company]", "find their tells", "weakness map", "recon this prospect", "why would they buy", "what are their gaps", "build the dossier", or before any bid, deck, demo, or outreach so positioning rests on demonstrated gaps instead of generic value props. Runs one prospect or fans out across many. Produces a cited dossier with severity/provability/monetizability scores, a live-demo wedge list, a quarantined-hypotheses section, and a NEEDS/UNKNOWNS handoff — never client-facing.

The compounding engine of signal-forge — captures reusable knowledge atoms from every run and every human correction, traces each correction to the exact factory line that allowed it, writes append-only ledgers with a same-transaction discoverability index, and refreshes decay-prone atoms on a cadence so run

Builds the proposal slide deck for a prospect — an animated single-file HTML deck by default, .pptx when the buyer's meeting culture demands Office, or both — walking from evidenced weaknesses (tells) to the sign-here moment. Use when the user says "pitch deck", "proposal deck", "slides for [prospect]", "deck for the meeting", or as the 05-deck stage of a factory run. Every number comes from SYNTHESIS; every scope item traces to a tell; the tells ↔ scope ↔ price bijection is the spine. The HTML artifact is a precise, buildable spec (16:9 stage, anime.js v4, `--sf-*` tokens, ≤2.5MB, zero console errors, WCAG AA, prefers-reduced-motion) — not a vibe.

Design the context strategy for a project or working session — what knowledge to keep, where it lives, what to load when, how to compress it, and how to hand it off — so work stays grounded and compounds across sessions instead of starting cold every time. Use whenever someone wants their setup to remember and reuse context: "set up memory for this project", "what context should the agent have", "stop re-explaining everything", "organize my project knowledge", "design a CLAUDE.md / context file", "session handoff", "context engineering", "meta-context", or "/meta-context". Task-agnostic. Produces a durable substrate plan, a load/compression policy, a persistence & handoff policy, a discoverability index, and a starter substrate scaffold — in plain language. Do NOT use for a one-off question with no project or continuity.

Apply the discipline of craft — building things that survive contact with reality and stay easy to change — to any project, and emit a project-specific craft constitution plus a Definition of Done. Use whenever someone wants work done to a senior standard rather than a quick-and-dirty one: "do this properly", "make it production-grade", "what's the craft standard here", "give me a definition of done", "review this for quality", "clear not clever", "avoid slop", "meta-craft", or "/meta-craft". Task-agnostic — works for code, writing, design, analysis, or operations. Produces a tailored set of craft rules, a slop-vs-craft contrast for the work at hand, and an evidence-based completion checklist, in plain language. Do NOT use for genuinely disposable throwaway work where polish has no value.

Derive a typed, medium-specific DESIGN SCHEMA from any design brief, then execute it into an audited, self-contained artifact plus the design system that generates it. Use whenever the user wants to design — but design rigorously and reusably rather than by imitation — teaching material, slides, animations, web pages, dashboards, or adjacent media. Triggers include "meta-design", "/meta-design", "derive a design system for X", "design schema", "build the system then all the instances", "make a design generator not a one-off", "audited design with WCAG predicates", "tokens + component library + composed artifact", or any request to map a brief into a structure-preserving design meta-prompt. This skill operates one level up: it emits the medium-specific schema that designs the whole category the brief belongs to, executes it through a render-and-verify loop, and refines via critique edit-scripts until convergence. Do NOT use for a single ad-hoc visual with no reuse and no audit requirement.

Turn a minimal prompt — even one line — into a complete, WOW-grade deliverable bundle, right-sized to the domain and scope: grounded research, a project vision, a reusable meta-prompt, an execution plan, a grounded data model, and the production-quality artifacts that fit the work (interactive dashboards for a data/pitch/ops product, a report or doc site, an API/spec, a prototype — whatever the domain needs), plus an optional animated explainer with custom SVG. Research-grounded, mobile-ready, and adapts on call to different business/domain needs. Use when the user says meta-mvp, build an MVP or vision or prototype for something, go from this one-liner to something I can show, make me the full pitch, or spin up a new project for a client. Resolves its own scoping by default (never interrogates you — it studies the task's structure and, for high-stakes ambiguity, cross-checks with a small agent panel) and asks only if you opt in. Optionally composes meta-prompting, meta-planning, research-synthesis, user-resea

Generate a customized META-PLAN — a typed, example-agnostic planning scaffold — before any complete plan is written, for agentic tasks executed by one or many agents. Bridges /meta-prompting (generic tasks) to agentic planning (ultraplan-class capability). Use whenever the user wants to plan work that agents will execute, orchestrate subagents, decompose a complex build, decide what can run in parallel vs. in sequence, hand context-complete work packets to fresh agents, or asks for "meta-plan", "/meta-planning", "ultraplan", "plan the plan", "deep planning", "map the domain before planning", or "a plan another agent can execute without me". Also use when the input TASK is itself a meta-prompt (operating from meta-meta-prompt space), or when the user wants anti-slop quality gates and kaizen-style iterative execution baked into a plan. Do NOT use for simple single-agent to-do lists a direct plan would serve.

Generate a structured, example-agnostic META-PROMPT from any input task — a reusable "how to think" scaffold rather than worked examples. Use this whenever the user wants to design a prompt/system prompt for a CATEGORY of tasks, build a prompt template or reasoning harness, turn a one-off prompt into a reusable structure, create an "expert persona" system prompt with typed slots, or apply Meta Prompting / Recursive Meta Prompting (RMP). Triggers include "write a meta-prompt", "design a system prompt for X tasks", "make a reusable prompt template", "prompt that works for any category of problem", "structure the reasoning for this task", "self-improving prompt", "functor/typed-slot prompt", or any request to map an input task into a valid meta-prompt. This skill maps the meta-meta-prompt space: given a task, it emits the meta-prompt that solves the whole category.

Run a rigorous, task-agnostic research scaffold — decompose a question, fan out across sources, triage by credibility, cross-verify claims adversarially, and synthesize a cited answer with explicit confidence — then leave behind reusable knowledge atoms. Use whenever someone needs something investigated properly rather than answered off the cuff: "research X", "look into Y", "what's the latest on Z", "find sources for", "verify this claim", "compare these options with evidence", "deep dive", "meta-research", or "/meta-research". Task-agnostic across any subject. Produces a structured, sourced brief with confidence levels and open questions, plus 1-3 durable knowledge atoms for reuse. Do NOT use for questions answerable from common knowledge with no need for sources or verification.

Derive the right set of review lenses for any deliverable and run an adversarial, multi-perspective review that returns prioritized findings plus a reusable lesson — so the same problem gets caught automatically next time. Use whenever someone wants something checked rigorously before it ships: "review this", "what's wrong with this", "tear this apart", "is this ready", "red-team this", "find the problems", "critique my plan/code/doc/design", "meta-review", or "/meta-review". Task-agnostic — works for code, writing, plans, designs, analyses, or decisions. Produces P1/P2/P3 findings with rationale, the author's blind-spot probes, an ordered fix list, and a durable lesson atom. Do NOT use to generate new content from scratch (use the relevant maker skill first, then review its output).

Comprehensive Elm functional programming for web development including The Elm Architecture, type system, JavaScript interop, and production-ready patterns

Master the Purify library for practical functional programming in TypeScript with algebraic data types (Maybe, Either, EitherAsync, MaybeAsync), composable error handling, data transformations, Codec for runtime type safety, List operations, Tuple utilities, and functional patterns. Use when working with Purify's Maybe/Either types, async error handling with EitherAsync/MaybeAsync, runtime validation with Codecs, or building practical functional TypeScript applications with cleaner syntax than fp-ts.

Comprehensive F* proof-oriented programming for formal verification including dependent types, refinement types, effect system, SMT solver integration, tactic-based interactive theorem proving, and verified code extraction to OCaml, F#, C, WebAssembly, and Assembly

Comprehensive Express.js development skill covering routing, middleware, request/response handling, error handling, and building production-ready REST APIs

Comprehensive PostgreSQL database administration skill for customer support tech enablement, covering database design, optimization, performance tuning, backup/recovery, and advanced query techniques

Use when generating WOW-level animated components for course pages, dashboards, hero sections, product landing pages, or technical demos. Triggers on 'animated component', 'make this WOW', 'add animation', 'magnetic button', 'number ticker / number flow', 'bento grid', 'hero text reveal', 'hero parallax', 'sticky scroll', 'animated beam', 'dynamic island', '3D tilt card', 'border beam', 'shadcn animations', 'smoothui style', 'aceternity style', 'magic UI', 'motion primitives', 'react bits', 'animate UI', 'cult UI', 'animated dashboard widget', 'scroll storytelling', 'KPI counter', 'animated background', 'interactive experience'. Also use when extending the codebase-to-course design system with motion, building interactive course tutorials beyond single-page HTML, or producing dashboard widgets with data-viz motion. Hybrid shadcn structure + smoothui motion vocabulary.