oh-my-hermes-workflow

# oh-my-hermes-workflow > Skill by [ara.so](https://ara.so) — Hermes Skills collection. Oh My Hermes is an opinionated workflow layer for building, shipping, and operating apps with Hermes Agent. It provides 23+ curated skills that enable Hermes to autonomously handle the complete software lifecycle — from requirements clarification to production deployment and monitoring. ## What Oh My Hermes Does - **Full Project Lifecycle**: Takes projects from idea to production with autonomous workflows - **Autonomous CTO Loop**: Hourly issue triage, implementation, security review, and deployment approval flow - **Multi-Agent Orchestration**: PM, Dev, QA, Security, and Ops agents working together via Kanban - **Persistent Memory**: Hermes remembers project context, requirements, and decisions across sessions - **Integration Layer**: Connects Hermes with Claude Code, Codex, Vercel, Supabase, GitHub, Sentry ## Installation ### Prerequisites 1. **Install Hermes Agent first**: Follow [Hermes quickstart](https://hermes-agent.nousresearch.com/docs/getting-started/quickstart) 2. **Configure messaging**: Set up Telegram, Slack, Discord, or WhatsApp gateway 3. **Verify Hermes is running**: Test by messaging your Hermes bot ### Install Oh My Hermes ```bash # One-line install curl -fsSL https://raw.githubusercontent.com/salomondiei08/oh-my-hermes/main/install.sh | bash # Or clone and install manually git clone https://github.com/salomondiei08/oh-my-hermes /tmp/oh-my-hermes bash /tmp/oh-my-hermes/install.sh ``` ### Bootstrap a Project ```bash # Navigate to your project directory cd /path/to/your/project # Run bootstrap script bash /tmp/oh-my-hermes/scripts/bootstrap.sh # Verify installation bash /tmp/oh-my-hermes/scripts/verify.sh ``` ### Message-Based Setup (Recommended) Once installed, message your Hermes bot: ``` set up the CTO loop ``` Hermes will guide you through: - GitHub repository configuration - Fine-grained token creation - Production URL setup - Webhook configuration - Monitoring setup ## Key Skills Oh My Hermes provides 23+ skills loaded into `~/.hermes/skills/`: ### Onboarding & Planning **onboarding** ```bash # Trigger in Hermes chat "walk me through setting up oh my hermes" ``` Guides full setup in chat — no terminal required. **clarify-requirements** ```bash # Trigger in Hermes chat "start a new app" "clarify requirements for this project" ``` Asks 7 structured questions, saves answers to Hermes memory. **product-brief** ```bash # Trigger after clarify-requirements "generate the product brief" ``` Creates `PRODUCT_BRIEF.md` from requirements. **design-handoff** ```bash # Trigger in Hermes chat "convert my design to implementation spec" ``` Transforms design notes into technical specifications. ### Implementation **choose-engine** ```bash # Trigger in Hermes chat "implement this feature" ``` Routes tasks to Hermes, Claude Code, or Codex based on complexity. **implement-with-claude-code** ```bash # Invoked by choose-engine for complex multi-file tasks # Scaffolds Claude Code with: # - Full project context # - Scope constraints # - Security guardrails ``` **implement-with-codex** ```bash # Invoked by choose-engine for single-file fixes # Quick targeted edits ``` ### Deployment **deploy-to-vercel** ```bash # Trigger in Hermes chat "deploy to vercel" "ship this to production" ``` Example workflow: 1. Pre-deploy checks (secrets scan, build validation) 2. Deploys to Vercel 3. Captures preview/production URL 4. Runs health checks 5. Notifies via configured channel **connect-supabase** ```bash # Trigger in Hermes chat "connect supabase" "set up database" ``` Handles: - Database linking - Migration pushing - Environment variable configuration in Vercel - Connection validation ### Monitoring **setup-monitoring** ```bash # Trigger in Hermes chat "set up monitoring" ``` Configures: - Sentry error tracking - Uptime Kuma health checks - Alert webhooks **health-check** ```bash # Runs automatically every 15 minutes # Manual trigger: "run health check" ``` Validates: - `/api/health` endpoint response - Supabase connectivity - Vercel deployment status - Response times ### GitHub Integration **manage-github-issues** ```bash # Trigger in Hermes chat "triage github issues" "create issue for bug in login" "close issue #42" ``` **create-github-pr** ```bash # Automatic during implementation workflow # Includes: # - Secret scan before PR creation # - Conventional commit messages # - Linked issue references ``` **auto-issue-triage** ```bash # Runs hourly via cron # Scores issues by: # - User impact # - Business priority # - Technical debt # Picks top priority and starts implementation ``` **review-github-pr** ```bash # Automatic when PR is ready # Provides: # - Diff analysis # - Security checks # - Plain-English summary # - Preview URL validation ``` **security-review** ```bash # Runs on every PR # Weekly supply chain audit "run security review on PR #12" ``` Checks: - Secret scanning (no API keys, tokens) - OWASP top 10 vulnerabilities - CVE audit of dependencies - Supply chain security (weekly) ## Configuration ### Environment Variables Create `.hermes/config.env`: ```bash # GitHub Integration GITHUB_OWNER=your-username GITHUB_REPO=your-repo GITHUB_TOKEN=${GITHUB_TOKEN} # Fine-grained token with repo access # Deployment VERCEL_TOKEN=${VERCEL_TOKEN} # Vercel API token VERCEL_PROJECT_ID=${VERCEL_PROJECT_ID} VERCEL_ORG_ID=${VERCEL_ORG_ID} # Database SUPABASE_URL=${SUPABASE_URL} SUPABASE_ANON_KEY=${SUPABASE_ANON_KEY} SUPABASE_SERVICE_KEY=${SUPABASE_SERVICE_KEY} # Monitoring SENTRY_DSN=${SENTRY_DSN} UPTIME_KUMA_URL=${UPTIME_KUMA_URL} UPTIME_KUMA_TOKEN=${UPTIME_KUMA_TOKEN} # Notifications SLACK_WEBHOOK_URL=${SLACK_WEBHOOK_URL} TELEGRAM_BOT_TOKEN=${TELEGRAM_BOT_TOKEN} TELEGRAM_CHAT_ID=${TELEGRAM_CHAT_ID} # Production PRODUCTION_URL=https://yourapp.com ``` ### Hermes Memory Configuration Oh My Hermes stores project context in Hermes memory at: ``` ~/.hermes/memory/ ├── requirements.json # From clarify-requirements ├── product-brief.md # Generated brief ├── kanban-state.json # Current task status └── deployment-log.json # Deployment history ``` ### Kanban Configuration The autonomous loop uses a simple Kanban: ``` Backlog → In Progress → Review → Done ``` Stored in `~/.hermes/memory/kanban-state.json`: ```json { "backlog": [ {"id": "issue-42", "priority": 8, "title": "Fix login redirect"} ], "in_progress": [ {"id": "issue-39", "assigned": "dev-agent", "started": "2026-05-16T10:00:00Z"} ], "review": [ {"id": "pr-12", "reviewer": "security-agent", "checks": ["secret-scan", "owasp"]} ], "done": [ {"id": "issue-38", "completed": "2026-05-15T14:30:00Z", "deployed": true} ] } ``` ## Real-World Workflows ### Start a New App from Scratch Message your Hermes bot: ``` Start a new app called TaskFlow — a Kanban board for small teams ``` Hermes will: 1. Load `clarify-requirements` skill 2. Ask 7 questions about your app 3. Generate `PRODUCT_BRIEF.md` 4. Run `choose-engine` to decide implementation approach 5. Implement the app 6. Deploy to Vercel 7. Set up monitoring ### Implement a Feature Message your Hermes bot: ``` Add Google OAuth login to the app ``` Hermes workflow: 1. Creates GitHub issue 2. Dev Agent implements 3. Security Agent scans for secrets 4. QA Agent validates build and preview 5. Sends you approval message: ``` PR #15 — Add Google OAuth login What changed: Users can now sign in with Google. Added /api/auth/google endpoint and callback handler. Build: passing | Preview: healthy (200ms) | No secrets found Preview: https://taskflow-oauth.vercel.app Reply YES to ship. Reply NO and tell me why. ``` 6. You reply `YES` 7. Merges, deploys, health-checks, confirms ### Manual Deployment ```bash # From your project directory cd /path/to/your/project # Message Hermes: "deploy to vercel" # Or run skill directly (if configured) hermes run deploy-to-vercel ``` ### Security Audit ```bash # Message Hermes: "run security review on main branch" # Hermes will: # - Scan for hardcoded secrets # - Check dependencies for CVEs # - Run OWASP checks # - Generate report ``` ### Health Check ```bash # Message Hermes: "check if production is healthy" # Hermes validates: # - Production URL responds # - Database is connected # - API endpoints work # - Response times are acceptable ``` ## Autonomous CTO Loop Once configured, this runs every hour automatically: ``` ┌─────────────────────────────────────────┐ │ GitHub Issue Opened (#42) │ └───────────┬─────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ PM Agent (auto-issue-triage) │ │ - Scores issue: priority 8/10 │ │ - Moves to Backlog │ └───────────┬─────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ Dev Agent (implement) │ │ - Moves to In Progress │ │ - Writes code │ │ - Creates PR #12 │ └───────────┬─────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ Security Agent (security-review) │ │ - Secret scan: PASS │ │ - OWASP check: PASS │ │ - CVE scan: PASS │ └───────────┬─────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ QA Agent (review-github-pr) │ │ - Build: passing │ │ - Health check: 180ms │ │ - Plain-English summary written │ │ - Moves to Review │ └───────────┬─────────────────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ Notification Sent (YOU on Telegram) │ │ "PR #12 ready. Reply YES to ship." │ └───────────┬─────────────────────────────┘ │ ┌──────┴──────┐ │ │ ▼ ▼ ┌─────┐ ┌──────┐ │ YES │ │ NO │ └──┬──┘ └───┬──┘ │ │ │ ▼ │ ┌────────────────┐ │ │ Dev Agent │ │ │ iterates on │ │ │ your feedback │ │ └────────────────┘ │ ▼ ┌─────────────────────────────────────────┐ │ Ops Agent │ │ - Merges PR │ │ - Deploys to production │ │ - Runs health check │ │ - Confirms live URL │ │ - Moves to Done │ └─────────────────────────────────────────┘ ``` ## Common Patterns ### Goal-Oriented Sessions Use `/goal` command to keep Hermes focused: ``` /goal Build a working MVP of TaskFlow with Google OAuth, deploy to Vercel, and set up monitoring — all within the next 2 hours ``` Hermes will: - Break down the goal into sub-tasks - Execute each step autonomously - Check in with you at key decision points - Persist progress across interruptions ### Custom Skill Creation Create project-specific skills: ```bash # Message Hermes: "create a new skill for automated database backups" # Hermes will: # - Use create-skill meta-skill # - Generate skill template # - Save to ~/.hermes/skills/db-backup.md # - Make it available for invocation ``` Skill structure: ```markdown --- name: db-backup description: Automated Supabase database backup to S3 triggers: - "backup the database" - "create db backup" --- # db-backup ## What it does Creates timestamped backup of Supabase database and uploads to S3. ## Prerequisites - Supabase CLI installed - AWS credentials configured - S3 bucket created ## Steps 1. Export database: `supabase db dump -f backup.sql` 2. Compress: `gzip backup.sql` 3. Upload: `aws s3 cp backup.sql.gz s3://my-backups/$(date +%Y%m%d-%H%M%S).sql.gz` 4. Verify upload 5. Clean up local files 6. Notify completion ## Configuration - S3_BUCKET=${S3_BUCKET} - SUPABASE_PROJECT_REF=${SUPABASE_PROJECT_REF} ``` ### Scheduled Tasks Configure cron jobs in `~/.hermes/cron.d/`: ```bash # Hourly issue triage 0 * * * * hermes run auto-issue-triage # Daily deployment report 0 9 * * * hermes run daily-report # Weekly security audit 0 2 * * 0 hermes run security-review --full-audit # Every 15 minutes health check */15 * * * * hermes run health-check ``` ### Integration with Claude Code When a task requires deep multi-file editing: ```bash # Message Hermes: "refactor the authentication system to use sessions instead of JWT" # Hermes workflow: # 1. choose-engine analyzes complexity # 2. Determines Claude Code is needed # 3. Scaffolds Claude Code session with: # - Full project context # - Relevant files identified # - Scope constraints # - Security requirements # 4. Claude Code performs refactor # 5. Hermes reviews changes # 6. Creates PR for your approval ``` ## Troubleshooting ### Hermes Not Loading Skills ```bash # Verify skills directory ls -la ~/.hermes/skills/ # Re-run installer bash /tmp/oh-my-hermes/install.sh # Check Hermes logs tail -f ~/.hermes/logs/hermes.log ``` ### GitHub Integration Failing ```bash # Verify token has correct permissions # Required: repo (full), workflow, admin:repo_hook # Test token manually curl -H "Authorization: Bearer ${GITHUB_TOKEN}" \ https://api.github.com/repos/${GITHUB_OWNER}/${GITHUB_REPO} # Reconfigure in Hermes chat: "reconfigure github integration" ``` ### Deployment Issues ```bash # Verify Vercel token vercel whoami # Check environment variables are set