HermeticOrmus

prompt-engineering-patterns

Master advanced prompt engineering techniques to maximize LLM performance, reliability, and controllability in production. Use when optimizing prompts, improving LLM outputs, or designing production prompt templates.

18 Updated 2 weeks ago

fastapi-templates

Create production-ready FastAPI projects with async patterns, dependency injection, and comprehensive error handling. Use when building new FastAPI applications or setting up backend API projects.

api-design-principles

Master REST and GraphQL API design principles to build intuitive, scalable, and maintainable APIs that delight developers. Use when designing new APIs, reviewing API specifications, or establishing API design standards.

architecture-patterns

Implement proven backend architecture patterns including Clean Architecture, Hexagonal Architecture, and Domain-Driven Design. Use when architecting complex backend systems or refactoring existing applications for better maintainability.

microservices-patterns

Design microservices architectures with service boundaries, event-driven communication, and resilience patterns. Use when building distributed systems, decomposing monoliths, or implementing microservices.

temporal-python-testing

Test Temporal workflows with pytest, time-skipping, and mocking strategies. Covers unit testing, integration testing, replay testing, and local development setup. Use when implementing Temporal workflow tests or debugging test failures.

workflow-orchestration-patterns

Design durable workflows with Temporal for distributed systems. Covers workflow vs activity separation, saga patterns, state management, and determinism constraints. Use when building long-running processes, distributed transactions, or microservice orchestration.

defi-protocol-templates

Implement DeFi protocols with production-ready templates for staking, AMMs, governance, and lending systems. Use when building decentralized finance applications or smart contract protocols.

nft-standards

Implement NFT standards (ERC-721, ERC-1155) with proper metadata handling, minting strategies, and marketplace integration. Use when creating NFT contracts, building NFT marketplaces, or implementing digital asset systems.

solidity-security

Master smart contract security best practices to prevent common vulnerabilities and implement secure Solidity patterns. Use when writing smart contracts, auditing existing contracts, or implementing security measures for blockchain applications.

web3-testing

Test smart contracts comprehensively using Hardhat and Foundry with unit tests, integration tests, and mainnet forking. Use when testing Solidity contracts, setting up blockchain test suites, or validating DeFi protocols.

deployment-pipeline-design

Design multi-stage CI/CD pipelines with approval gates, security checks, and deployment orchestration. Use when architecting deployment workflows, setting up continuous delivery, or implementing GitOps practices.

github-actions-templates

Create production-ready GitHub Actions workflows for automated testing, building, and deploying applications. Use when setting up CI/CD with GitHub Actions, automating development workflows, or creating reusable workflow templates.

gitlab-ci-patterns

Build GitLab CI/CD pipelines with multi-stage workflows, caching, and distributed runners for scalable automation. Use when implementing GitLab CI/CD, optimizing pipeline performance, or setting up automated testing and deployment.

hybrid-cloud-networking

Configure secure, high-performance connectivity between on-premises infrastructure and cloud platforms using VPN and dedicated connections. Use when building hybrid cloud architectures, connecting data centers to cloud, or implementing secure cross-premises networking.

multi-cloud-architecture

Design multi-cloud architectures using a decision framework to select and integrate services across AWS, Azure, and GCP. Use when building multi-cloud systems, avoiding vendor lock-in, or leveraging best-of-breed services from multiple providers.

terraform-module-library

Build reusable Terraform modules for AWS, Azure, and GCP infrastructure following infrastructure-as-code best practices. Use when creating infrastructure modules, standardizing cloud provisioning, or implementing reusable IaC components.

postgresql-table-design

Design a PostgreSQL-specific schema. Covers best-practices, data types, indexing, constraints, performance patterns, and advanced features

auth-implementation-patterns

Master authentication and authorization patterns including JWT, OAuth2, session management, and RBAC to build secure, scalable access control systems. Use when implementing auth systems, securing APIs, or debugging security issues.

code-review-excellence

Master effective code review practices to provide constructive feedback, catch bugs early, and foster knowledge sharing while maintaining team morale. Use when reviewing pull requests, establishing review standards, or mentoring developers.

debugging-strategies

Master systematic debugging techniques, profiling tools, and root cause analysis to efficiently track down bugs across any codebase or technology stack. Use when investigating bugs, performance issues, or unexpected behavior.

e2e-testing-patterns

Master end-to-end testing with Playwright and Cypress to build reliable test suites that catch bugs, improve confidence, and enable fast deployment. Use when implementing E2E tests, debugging flaky tests, or establishing testing standards.

error-handling-patterns

Master error handling patterns across languages including exceptions, Result types, error propagation, and graceful degradation to build resilient applications. Use when implementing error handling, designing APIs, or improving application reliability.

git-advanced-workflows

Master advanced Git workflows including rebasing, cherry-picking, bisect, worktrees, and reflog to maintain clean history and recover from any situation. Use when managing complex Git histories, collaborating on feature branches, or troubleshooting repository issues.

sql-optimization-patterns

Master SQL query optimization, indexing strategies, and EXPLAIN analysis to dramatically improve database performance and eliminate slow queries. Use when debugging slow queries, designing database schemas, or optimizing application performance.

angular-migration

Migrate from AngularJS to Angular using hybrid mode, incremental component rewriting, and dependency injection updates. Use when upgrading AngularJS applications, planning framework migrations, or modernizing legacy Angular code.

database-migration

Execute database migrations across ORMs and platforms with zero-downtime strategies, data transformation, and rollback procedures. Use when migrating databases, changing schemas, performing data transformations, or implementing zero-downtime deployment strategies.

dependency-upgrade

Manage major dependency version upgrades with compatibility analysis, staged rollout, and comprehensive testing. Use when upgrading framework versions, updating major dependencies, or managing breaking changes in libraries.

react-modernization

Upgrade React applications to latest versions, migrate from class components to hooks, and adopt concurrent features. Use when modernizing React codebases, migrating to React Hooks, or upgrading to latest React versions.

javascript-testing-patterns

Implement comprehensive testing strategies using Jest, Vitest, and Testing Library for unit tests, integration tests, and end-to-end testing with mocking, fixtures, and test-driven development. Use when writing JavaScript/TypeScript tests, setting up test infrastructure, or implementing TDD/BDD workflows.

modern-javascript-patterns

Master ES6+ features including async/await, destructuring, spread operators, arrow functions, promises, modules, iterators, generators, and functional programming patterns for writing clean, efficient JavaScript code. Use when refactoring legacy code, implementing modern patterns, or optimizing JavaScript applications.

nodejs-backend-patterns

Build production-ready Node.js backend services with Express/Fastify, implementing middleware patterns, error handling, authentication, database integration, and API design best practices. Use when creating Node.js servers, REST APIs, GraphQL backends, or microservices architectures.

typescript-advanced-types

Master TypeScript's advanced type system including generics, conditional types, mapped types, template literals, and utility types for building type-safe applications. Use when implementing complex type logic, creating reusable type utilities, or ensuring compile-time type safety in TypeScript projects.

gitops-workflow

Implement GitOps workflows with ArgoCD and Flux for automated, declarative Kubernetes deployments with continuous reconciliation. Use when implementing GitOps practices, automating Kubernetes deployments, or setting up declarative infrastructure management.

helm-chart-scaffolding

Design, organize, and manage Helm charts for templating and packaging Kubernetes applications with reusable configurations. Use when creating Helm charts, packaging Kubernetes applications, or implementing templated deployments.

k8s-manifest-generator

Create production-ready Kubernetes manifests for Deployments, Services, ConfigMaps, and Secrets following best practices and security standards. Use when generating Kubernetes YAML manifests, creating K8s resources, or implementing production-grade Kubernetes configurations.

k8s-security-policies

Implement Kubernetes security policies including NetworkPolicy, PodSecurityPolicy, and RBAC for production-grade security. Use when securing Kubernetes clusters, implementing network isolation, or enforcing pod security standards.

langchain-architecture

Design LLM applications using the LangChain framework with agents, memory, and tool integration patterns. Use when building LangChain applications, implementing AI agents, or creating complex LLM workflows.

llm-evaluation

Implement comprehensive evaluation strategies for LLM applications using automated metrics, human feedback, and benchmarking. Use when testing LLM performance, measuring AI application quality, or establishing evaluation frameworks.

rag-implementation

Build Retrieval-Augmented Generation (RAG) systems for LLM applications with vector databases and semantic search. Use when implementing knowledge-grounded AI, building document Q&A systems, or integrating LLMs with external knowledge bases.

ml-pipeline-workflow

Build end-to-end MLOps pipelines from data preparation through model training, validation, and production deployment. Use when creating ML pipelines, implementing MLOps practices, or automating model training and deployment workflows.

distributed-tracing

Implement distributed tracing with Jaeger and Tempo to track requests across microservices and identify performance bottlenecks. Use when debugging microservices, analyzing request flows, or implementing observability for distributed systems.

grafana-dashboards

Create and manage production Grafana dashboards for real-time visualization of system and application metrics. Use when building monitoring dashboards, visualizing metrics, or creating operational observability interfaces.

prometheus-configuration

Set up Prometheus for comprehensive metric collection, storage, and monitoring of infrastructure and applications. Use when implementing metrics collection, setting up monitoring infrastructure, or configuring alerting systems.

slo-implementation

Define and implement Service Level Indicators (SLIs) and Service Level Objectives (SLOs) with error budgets and alerting. Use when establishing reliability targets, implementing SRE practices, or measuring service performance.

billing-automation

Build automated billing systems for recurring payments, invoicing, subscription lifecycle, and dunning management. Use when implementing subscription billing, automating invoicing, or managing recurring payment systems.

paypal-integration

Integrate PayPal payment processing with support for express checkout, subscriptions, and refund management. Use when implementing PayPal payments, processing online transactions, or building e-commerce checkout flows.

absorb

Distill session knowledge into persistent memory — project intent, domain understanding, architectural decisions, and vision. The learning ritual.

geo-content

Content quality and E-E-A-T assessment for AI citability — evaluate experience, expertise, authoritativeness, trustworthiness, and content structure

geo-platform-optimizer

Platform-specific AI search optimization — audit and optimize for Google AI Overviews, ChatGPT, Perplexity, Gemini, and Bing Copilot individually

geo-report-pdf

Generate a professional PDF report from GEO audit data using ReportLab. Creates a polished, client-ready PDF with score gauges, bar charts, platform readiness visualizations, color-coded tables, and prioritized action plans.

geo-report

Generate a professional, client-facing GEO report combining all audit results into a single deliverable with scores, findings, and prioritized actions

geo-schema

Schema.org structured data audit and generation optimized for AI discoverability — detect, validate, and generate JSON-LD markup

geo-technical

Technical SEO audit with GEO-specific checks — crawlability, indexability, security, performance, SSR, and AI crawler access

osint

OSINT (Open-Source Intelligence) research methodology — multi-wave investigative spiral. Public sources only. Structured intel briefing output with citations, network diagrams, timelines, and prediction matrices. Use for due diligence, competitive intel, journalism research.

1 Updated 2 weeks ago

vibe-proof

Security-focused hardening for vibe-coded full-stack apps. Runs parallel audits across frontend, backend, and config layers, then fixes issues systematically by severity. Covers injection, PII exposure, missing headers, error leakage, dead code, and credential hygiene.

vibe-proof

brand-systems

Building comprehensive brand identity systems from strategy to implementation. Covers logo design, color palettes, typography pairing, voice guidelines, and system documentation. Use when creating new brands, rebranding, or systematizing existing identities.

design-masters

Deep knowledge of legendary designers and their enduring contributions. Learn from Saul Bass, Massimo Vignelli, Dieter Rams, Paula Scher, and others whose work defines excellence. Use when seeking inspiration, understanding design history, or applying proven approaches.

design-movements

Historical design movements and their enduring influence. Understand Bauhaus, Swiss International Style, Art Deco, Memphis, and more. Use when choosing an aesthetic direction, understanding cultural context, or predicting trend cycles.

design-principles

Core visual design principles that underpin all great design. Master gestalt psychology, visual hierarchy, composition, color theory, and typography fundamentals. Use when making design decisions or evaluating designs against proven principles.

notify-whatsapp

Send WhatsApp notification about completed work, errors, or important updates

send-whatsapp

Format and send conversational content via WhatsApp with rich formatting

dx-audit

Audit and improve developer experience in a codebase by inspecting README, quickstart, scripts, contributing guide, env docs, error messages, and tooling, scoring onboarding friction, and reporting findings or implementing fixes. Use when a new contributor hits friction, when setup is undocumented, or when the README has not been run on a clean checkout since the stack changed.

explore-code

Understand an unfamiliar codebase fast. Start with purpose, architecture, stack and entry points, map the directory structure, trace one representative flow end to end, then identify the core abstractions and where changes go. Use when landing in a repository you have never seen and need orientation before making a change.

mem-search

Search claude-mem's persistent cross-session memory database. Search for an index, filter, then fetch full details only for kept IDs, for 10x token savings. Use when the user asks "did we already solve this?", "how did we do X last time?", or needs work from previous sessions. Requires the claude-mem MCP.

claude-md-overhaul

Audit Claude Code memory layer end-to-end. Measure CLAUDE.md/MEMORY.md against caps, find sync conflicts, identify gaps tier-by-tier. Use when memory feels bloated or invisible at session start, or as periodic hygiene.

unwoke

Strip AI theater and ideological bias from responses. No hedging, no disclaimers, no moralizing, no woke framing. Truth-seeking signal only. Symmetric engagement across positions. Use when you want direct answers without performative caution.

geo-audit

Full website GEO+SEO audit with parallel subagent delegation. Orchestrates a comprehensive Generative Engine Optimization audit across AI citability, platform analysis, technical infrastructure, content quality, and schema markup. Produces a composite GEO Score (0-100) with prioritized action plan.

geo-brand-mentions

Brand mention and authority scanner for AI visibility. Analyzes brand presence across platforms that AI models rely on for entity recognition and citation decisions. Produces a Brand Authority Score (0-100) with platform-specific recommendations.

geo-citability

AI citability scoring and optimization. Analyzes web page content to determine how likely AI systems (ChatGPT, Claude, Perplexity, Gemini) are to cite or quote passages from the page. Provides a citability score (0-100) with specific rewrite suggestions.

geo-crawlers

AI crawler access analysis. Checks robots.txt, meta tags, and HTTP headers to determine which AI crawlers can access the site. Provides a complete access map and recommendations for maximizing AI visibility while maintaining appropriate control.

geo-llmstxt

Analyzes and generates llms.txt files -- the emerging standard for helping AI systems understand website structure and content. Can validate existing llms.txt files or generate new ones from scratch by crawling the site.

geo

GEO-first SEO analysis tool. Optimizes websites for AI-powered search engines (ChatGPT, Claude, Perplexity, Gemini, Google AI Overviews) while maintaining traditional SEO foundations. Performs full GEO audits, citability scoring, AI crawler analysis, llms.txt generation, brand mention scanning, platform-specific optimization, schema markup, technical SEO, content quality (E-E-A-T), and client-ready GEO report generation. Use when user says "geo", "seo", "audit", "AI search", "AI visibility", "optimize", "citability", "llms.txt", "schema", "brand mentions", "GEO report", or any URL for analysis.

pickup

Read a HANDOFF.md and restore session context — or infer context from git history when no handoff exists. The entry ritual — the opposite of /handoff. Use at the start of a new session after a handoff, machine switch, or context clear.

handoff

Write a complete session state capture to a HANDOFF file, then instruct user to /compact or /clear. Use before switching machines, hitting context limits, or handing off to a future session. Handles single-project, multi-project, and multi-machine sessions explicitly.

automate

Turn a repetitive task into a reliable automation script. Scope the task and its frequency/inputs/outputs/edge cases, pick the simplest tool, implement the smallest version, add error handling and idempotency, dry-run then schedule. Use when the task is "automate this", "write a script for", or scheduling an unattended job.

tdd

Test-driven development discipline. Write the failing test first, then Red-Green-Refactor, one test at a time, minimal code to pass, test behavior not implementation. Use when implementing a feature or fixing a bug test-first in JavaScript/TypeScript or Python.

hypothesis-debugging

Hypothesis-driven debugging protocol — reproduce, isolate, hypothesize, test, fix, document. Use when debugging a failure, a failing test, a flaky CI run, or a production error. Write a ranked hypothesis table before any fix; find the root cause, not a workaround. The operational form of the vibe-engineer-skills principle "hypothesis before help."

naming

Product naming methodology. Mine the brand's existing vocabulary (catalog, corpus, DB, memory) first. Iteratively converge through register pivots. Scale to suite architecture when signal warrants. Use for product renames, new products in existing suites, components of larger systems.

calcinate

Stage 1 of the Magnum Opus. Burn project bloat to reveal essence — surgical, intent-anchored, multi-agent. Declare three-layer intent (business / architectural / stylistic), dispatch 4 parallel scans, produce tiered plan, execute per-item with verify + auto-revert. Reversible via git.

six-day-cycle

Six-Day Development Cycle — sustainable shipping cadence. Day 1 Ideate, Day 2 Design, Days 3-4 Build, Day 5 Test+Polish, Day 6 Launch, then mandatory Rest. Maps to Hermetic principles. Never 7-day weeks. Use for planning project cadence.

riper-workflow

RIPER methodology — Research, Innovate, Plan, Execute, Review. Five-phase systematic development with separation of concerns, persistent artifacts per phase, and approval gates. Use for architecture changes, multi-file refactors, migrations, or any work where mistakes compound.

hermetic-laws

Seven Hermetic Principles applied to software engineering — Mentalism, Correspondence, Vibration, Polarity, Rhythm, Cause and Effect, Gender. Use when an engineering decision needs first-principles framing beyond pattern-matching.

python-conventions

Modern Python (3.11+) conventions — type discipline, pathlib, async patterns, structlog, ruff + mypy strict + pytest defaults. Use when writing or reviewing Python code.

commit-standard

Disciplined git commit messages following the Ormus Commit Standard (OCS) v1.0 — type(scope) structure, imperative subject, no emoji, no AI footers, atomicity rules. Use when writing commit messages.

shell-safety

Shell-safety discipline for bash/sh scripts — set -euo pipefail boilerplate, proper quoting, array handling, error patterns. Use when writing, modifying, or reviewing any shell script, Makefile, or .bashrc/.zshrc.

markdown-discipline

Markdown writing discipline that strips AI-slop tells — no em dashes, no marketing fluff, no emoji bullets, no triple-cataloging, no soft closes. Use when writing or editing any markdown content (README, docs, briefs).

vibe-engineer-guidelines

Behavioral guidelines for directing AI codegen well — hypothesis before help, scoped prompts, validate before accepting, reject working-but-wrong, AI output is a draft. Use when working with Claude Code or any AI coding tool. The companion to Karpathy guidelines.

agent-clean

Purge tasks from an autonomous coding agent that failed due to infrastructure errors (rate limits, credit exhaustion, auth failures, network) — not code failures. Cleans the queue without losing legitimate failures that need triage.

agent-evolve

Full-cycle improvement loop for an autonomous coding agent. Verify operational health, analyze pipeline state, research cutting-edge agent patterns, propose and apply improvements. The self-upgrading loop.

agent-inspect

Deep dive into a single task in an autonomous coding agent — details, log, events, dependencies, review verdict. Use when a task's behavior is mysterious or `/agent-triage` couldn't classify it.

agent-ops

Operational actions on tasks in an autonomous coding agent — stop, requeue, dead-letter, retry-subtasks, bump-priority. The mechanic's toolbox for running agents.

agent-status

At-a-glance overview of an autonomous coding agent — health, running tasks, queue, fail rate. Use to answer "is the agent working and what's it doing?" in a single dashboard.

agent-sweep-orphans

Triage orphan tasks in an autonomous coding agent — tasks marked "done" with commits or branches that never merged to main. Classifies each, shows the diff, and offers bulk merge / dead-letter / requeue dispositions.

agent-triage

Classify failed tasks from an autonomous coding agent, recommend disposition (retry / dead-letter / fix-and-retry / wontfix), and offer bulk action. Replaces reading hundreds of failure logs by hand.

smart-explore

Token-optimized structural code search using tree-sitter AST parsing. Use instead of reading full files when you need to understand code structure, find functions, or explore a codebase efficiently.

session-handoff

Session handoff discipline. Write HANDOFF.md at session end capturing state, key context not in diff, verify commands. Read at session start before doing anything else. Use to make multi-session work resumable.

go-based-tutors

Pattern for building interactive CLI tutors in Go with standardized colors, progress tracking, and pedagogical elements

1 Updated 2 weeks ago

mars

Brutal enforcer of production-grade coding practices. The bane of vibe-coded slop and spaghetti code. Mars audits codebases for the hidden sins that separate "it works on my machine" from battle-tested production systems.

1 Updated 2 weeks ago