Omh Backend logo

Omh Backend

CommunityPopular
rlaope
omh-backend

[omh] Hermes backend workflow: prepare server, API, and data-layer contracts — auth boundary, error paths, response shape, and schema/migration discipline — before implementation. Use when the user says: backend, back-end, back end, backend skill, server side, server-side, api design, api contract.

Overview

Publisherrlaope
Repositoryoh-my-hermes
Skill nameomh-backend
Stars
2.7K
Forks
194
Bundled files
3
LicenseMIT
Links
  • Markdown instructions

    A SKILL.md file the model loads on demand, so it only costs tokens when a request actually matches.

  • Works with any LLM

    AI skills are plain Markdown, not provider-specific code, so this works with GPT, Claude, Gemini, Grok, or a local model.

  • 3 bundled files

    Scripts, templates, and references the model can read while it works. Files are read-only and never executed.

  • Open source

    Published by rlaope on GitHub. Read the source before you install it.

Installation

Install the Omh Backend AI skill in TypingMind to use it with any LLM, or drop it into another agent that reads SKILL.md.

1

Install in TypingMind

TypingMind installs a skill straight from its GitHub folder — it reads SKILL.md, bundles the resource files, and stores the result locally.

  1. Open the app and go to Plugins → Skills.
  2. Choose "Install from GitHub".
  3. Paste the skill folder URL below and confirm.
  4. Enable the skill in any chat where you want it available.
Plugins → Skills → Add skill → From GitHub URL, then paste the folder URL and press Continue.
2

Install in another agent

Any agent that reads the Agent Skills format can use this skill — copy the folder into that agent's skills directory.

Claude Code — .claude/skills
git clone --depth 1 https://github.com/rlaope/oh-my-hermes.git /tmp/oh-my-hermes
mkdir -p .claude/skills
cp -r /tmp/oh-my-hermes/agent-skills/omh-backend .claude/skills/omh-backend
Restart Claude Code after copying so it picks up the new skill.

Use it in TypingMind

Enable Omh Backend in any TypingMind chat and the model takes it from there. Its name and description sit in the system prompt, and the moment a request matches, the model loads the full instructions itself — you never invoke it by hand, and it costs no tokens until it is actually used.

The model loads Omh Backend on its own as soon as a request matches it.

Works with any AI model

AI skills are plain Markdown instructions rather than provider-specific code, so Omh Backend is not tied to the model it was written for. Install it once in TypingMind and use it with GPT-5, Claude, Gemini, Grok, DeepSeek, Mistral, Llama, or a local model you run yourself — all on your own API keys.

  • Loaded only when it is needed

    The system prompt carries just the name and description. The instructions are fetched on the first matching request, so an idle skill costs nothing.

  • Switch models mid-chat

    Because the skill is instructions rather than code, changing model does not break it — the next model reads the same SKILL.md.

Skill instructions

This is the SKILL.md content the model loads. Read it before installing — a skill is instructions your model will follow.

Backend

This is an OMH backend workflow skill, projected for Agent Skills hosts (Claude Code, Codex, Cursor, opencode, OpenClaw, pi).

Why This Exists

backend gives OMH a first-class server-side workflow so Hermes can prepare auth boundaries, error paths, response shapes, and migration order without becoming the hidden runtime that executes them.

Do Not Use When

  • The request is about web UI, layout, or a design system; use frontend.
  • The request is a security posture or threat review rather than a service design; use security-safety-review.
  • The request is to run or judge the verification of an already-built service; use verification-gate.
  • The request is a Rust-language change whose risk is compiler, ownership, or unsafe discipline; use rust.

Examples

Good example:

  • Prompt: Design a REST API with a Postgres schema and migrations for the billing service.
  • Expected behavior: Prepare backend_service_contract/v1, auth_boundary_map/v1, error_path_table/v1, response_shape_contract/v1, and schema_migration_plan/v1, then hand off with the per-stack reference named.
  • Why: The request is server-side design across an endpoint surface and its storage, before any code exists.

Bad example:

  • Prompt: The migration is written, so mark the schema as migrated and the API as live.
  • Expected behavior: Mark migration application, integration runs, and deployment as not_observed and name the smallest observed proof for each.
  • Why: A prepared migration plan is not an applied migration, and a contract is not a running service.

Completion Checklist

  • The surface, its callers, and each caller's trust level are named.
  • The auth_boundary_map/v1 states where trust changes and which check enforces it on every path.
  • The error_path_table/v1 covers each failure mode with status, body shape, retryability, and redaction rule.
  • The response_shape_contract/v1 is consistent across endpoints rather than per-endpoint improvisation.
  • Storage changes carry an expand/backfill/switch/contract order with a rollback point per step.
  • A change to an existing contract carries its consumer list or an explicit consumers_not_enumerable, plus the compatibility window, migration path, and sunset date.
  • The handoff names the executor, the stack, and the per-stack reference to load first.
  • Implementation, migrations, integration runs, and deployment stay observed-only.

Recovery Notes

  • If the stack or datastore is unknown, prepare the contract stack-neutral and name the stack as the one blocking input.
  • If the auth model cannot be established, stop at the auth boundary gap instead of designing endpoints that assume a trust level.

Use When

Use when Hermes should shape a server, API, or data-layer change before implementation: authentication boundary, contract error paths, response consistency, schema and migration discipline, and the per-stack reference the executor loads first.

Strong routing signals: `backend`, `back-end`, `back end`, `backend skill`, `server side`, `server-side`, `api design`, `api contract`, `rest api`, `graphql api`, `grpc service`, `endpoint design`, `auth boundary`, `authentication flow`, `authorization rules`, `idempotency key`, `pagination contract`, `database schema`, `postgres schema`, `schema migration`, `db migration`, `orm mapping`, `connection pool`, `message queue`, `webhook handler`, `openapi`, `openapi spec`, `deprecate endpoint`, `deprecate this endpoint`, `deprecation window`, `sunset date`, `sunset schedule`, `api versioning`, `breaking api change`, `バックエンド`, `エンドポイント設計`, `認証フロー`, `スキーマ移行`, `백엔드`, `서버 개발`, `서버 api`, `api 설계`, `인증 흐름`, `권한 체크`, `디비 스키마`, `db 스키마`, `스키마 마이그레이션`, `엔드포인트 설계`, `后端`, `後端`, `接口设计`, `认证流程`, `数据库迁移`

Catalog Metadata

Category: planning Phase: backend-design Quality tier: backend-contract-gated Reasoning demand: standard

Quality bar:

  • Name the surface, its callers, and their trust level before any endpoint or table is designed.
  • Load references/service-contract.md and fill the auth boundary, error-path table, and response-shape rules from it rather than improvising a per-endpoint shape.
  • When the change touches storage, load references/schema-migration.md and order the migration as expand, backfill, switch, contract, with the rollback point named per step.
  • Hold the api product-family expectations — authentication boundary, contract error paths, response consistency — as the standing bar for every prepared endpoint.
  • When an existing contract changes, name who consumes it before designing the change: each identified consumer with what breaks for it, then the compatibility window, migration path, and sunset date — the skill that owns a surface owns its evolution. Load references/consumer-impact.md for the enumeration sources and the window rules.
  • Name the per-stack reference the executor must read first; the stack is a routing input, not a detail discovered mid-implementation.
  • Keep implementation, migration application, integration runs, load testing, and deployment as observed-only evidence.

Required inputs:

  • the service, endpoint, or data surface being changed
  • callers and their trust level (public, partner, internal, machine)
  • language, framework, and datastore when known
  • authentication and authorization model in force
  • existing schema and migration tooling
  • backward-compatibility and rollout constraints
  • observed integration or load evidence for completion claims

Expected outputs:

  • backend_service_contract/v1
  • auth_boundary_map/v1
  • error_path_table/v1
  • response_shape_contract/v1
  • schema_migration_plan/v1 when the change touches storage
  • consumer_impact_and_sunset/v1 when an existing contract changes
  • backend_implementation_handoff/v1
  • observed_integration_evidence/v1 when observed

Artifact expectations:

  • backend_service_contract/v1 names each endpoint or job, its caller class, request and response shapes, and its idempotency and pagination rules
  • auth_boundary_map/v1 states where an untrusted caller becomes a trusted one, and which check runs on each path
  • error_path_table/v1 pairs every failure mode with its status/code, body shape, retryability, and log/redaction rule
  • response_shape_contract/v1 keeps success and error envelopes consistent across the surface instead of per-endpoint improvisation
  • schema_migration_plan/v1 orders expand, backfill, switch, and contract steps with the rollback point for each
  • consumer_impact_and_sunset/v1 lists each identified consumer with what breaks for it, then the compatibility window, the migration path, and the sunset date; a consumer set that could not be enumerated is reported as consumers_not_enumerable with the reason, never as zero breakage
  • integration runs, applied migrations, load numbers, and deployment only when observed

Safety rules:

  • Do not claim implementation, a running service, an applied migration, a passing integration suite, or a deployment from a prepared backend contract.
  • Require the auth boundary before endpoint work: an endpoint whose caller trust level is unnamed is not ready for handoff.
  • Require the error-path table before the happy path is called complete; an unlisted failure mode is a gap, not a default.
  • Treat a destructive or non-reversible migration step as a blocker until an explicit rollback point and backfill order exist.
  • Report an unenumerable consumer set as consumers_not_enumerable with what was searched; consumers outside the repository are unknowable from it, and an empty list is a claim that nothing breaks.
  • Never place secrets, tokens, or connection strings in the contract, examples, or handoff text.
  • Do not call databases, HTTP services, LLM, or network endpoints from OMH core.

Runtime Evidence

Use the current host's own tools and subagent/task mechanism when available; otherwise run the same lanes sequentially or name the unavailable capability. A prepared plan, handoff, checklist, or skill installation is not execution, review, CI, merge-readiness, or merge evidence. Report actual tool results or not_observed / not_available; never invent dispatch or host accounting. Treat supplied context as advisory, not proof of hidden memory reads or writes. State scope, constraints, verification, and the stop condition before work. Supporting paths are relative to this skill directory; sibling skill paths are relative to its parent. Resolve them from the host-provided skill base directory ({baseDir} on hosts that provide it), never a hardcoded install location. A named workflow not installed here is unavailable, not permission to emulate its host-specific capabilities. Verify through the real surface before done.

Bundled files

The model reads these on demand while the skill is loaded. They are exposed as readable files and are never executed.

Frequently asked questions

What does the Omh Backend AI skill do?

[omh] Hermes backend workflow: prepare server, API, and data-layer contracts — auth boundary, error paths, response shape, and schema/migration discipline — before implementation. Use when the user says: backend, back-end, back end, backend skill, server side, server-side, api design, api contract.

Why use Omh Backend on TypingMind?

Because you install it once and use it with any model. Omh Backend is plain Markdown rather than provider-specific code, so the same skill runs on GPT-5, Claude, Gemini, Grok, or a local model — and you can switch model mid-chat without it breaking. TypingMind runs on your own API keys, so you pay providers directly instead of a per-seat subscription, and your skills and chats stay in your own storage.

How do I install Omh Backend in TypingMind?

Open Plugins → Skills → Install from GitHub in TypingMind and paste https://github.com/rlaope/oh-my-hermes/tree/main/agent-skills/omh-backend. TypingMind reads its SKILL.md and bundles its files and installs it as a skill you can enable per chat.

Which AI models can use Omh Backend?

Any model you connect in TypingMind. AI skills are plain Markdown instructions rather than provider-specific code, so GPT, Claude, Gemini, Grok, and local models can all load this skill when a request matches it.

How many AI models can I use with Omh Backend?

As many as you like. As long as a model supports skills, you can use Omh Backend with it — GPT, Claude, Gemini, Grok, DeepSeek, Mistral, Llama and more — all on TypingMind with your own API keys.

Is the Omh Backend AI skill free?

Yes. It is published on GitHub by rlaope under the MIT license. You only pay your own AI provider for the tokens you use.

What are AI skills?

An AI skill is a reusable instruction bundle that teaches an AI model how to do one specific task. It follows the open Agent Skills format: a SKILL.md file with a name and description, plus any scripts, templates or reference files the model may need. The model reads the instructions only when your request matches the skill, so an installed skill costs nothing until it is used.

How are AI skills different from plugins or MCP servers?

A plugin or MCP server gives a model new tools to call — code that runs somewhere and returns a result. An AI skill gives the model knowledge and process instead: how to approach a task, which steps to follow, what good output looks like. Skills are plain Markdown, so they need no server, no API key and no runtime, and they work with any model.

View all

Set up your own AI workspace now

Get notified about new features and future giveaways by subscribing to our newsletter 👇