New: 97,000+ skills indexed from GitHub repos with 100+ stars · every skill safety-checkedBrowse top skillsTop skills
Esc to closeBrowse all skills
Submit a skillBrowse skills
Submit a skillBrowse skills

Official agent skill

gh-aw Custom Engine Implementation

by github in github/gh-aw

Adds and tests declarative, behavior-defined agentic engines in GitHub Agentic Workflows, touching Go infrastructure only when the declarative model falls short.

OfficialMITAuto-check passedDevOps & Cloud

Install gh-aw Custom Engine Implementation

skills CLI
$ npx skills add github/gh-aw --skill custom-engine-implementation -a claude-code

Project install by default; add -g for ~/.claude/skills/.

GitHub CLI
$ gh skill install github/gh-aw custom-engine-implementation --agent claude-code

Project scope by default; add --scope user for a personal install. Needs GitHub CLI 2.90.0 or later (public preview).

Manual copy
$ git clone --depth 1 https://github.com/github/gh-aw.git skills-src && mkdir -p .claude/skills && cp -r skills-src/.github/skills/custom-engine-implementation .claude/skills/custom-engine-implementation && rm -rf skills-src

Use ~/.claude/skills/ instead of .claude/skills for a personal install. The folder must contain SKILL.md.

Claude Code skills documentation · loads skills from .claude/skills/

Facts

Skill name
custom-engine-implementation
GitHub stars
5.3k
Token cost
~1.9k tokens
SKILL.md length
844 words
Files
1
Skills in repo
52
Repo updated
First seen
Licence
MIT

At a glance

Adds and tests declarative, behavior-defined agentic engines in GitHub Agentic Workflows, touching Go infrastructure only when the declarative model falls short.

  • Works in 9 steps: Create .github/workflows/shared/.md. → Declare engine.id, display-name,… → Pin a default CLI version. Make… → …
  • Adding a new engine definition to gh-aw
  • SKILL.md covers Choose the smallest…, Study representative engines, Add a shared engine definition and Design the definition, plus 4 more sections
  • Calls make and go

What it does

The guiding rule is to choose the smallest implementation. A shared Markdown engine definition can already declare installation, execution, MCP configuration, provider routing, caching, manifests, plugins, network defaults, harness scripts and log parsing through engine.behaviors. Go code changes are for a reusable behavior the declarative model cannot express, and a dedicated Go engine is a last resort when the shared runtime cannot run the engine at all.

The skill names the files involved, among them the engine definition model, the behavior-defined runtime, the embedded definition loader, the agentic engine registry and the workflow schema, and points to existing shared definitions for opencode, aider, crush, cursor and deepseek-harness as patterns to study. Adding an engine means creating a shared Markdown file that declares its id, display name, description, experimental flag, provider metadata, authentication and only the behaviors it needs, pinning a default CLI version and giving a deterministic install with a verification command.

When your agent uses it

  • Adding a new engine definition to gh-aw
  • Deciding whether an engine needs Go changes or just a shared definition
  • Extending the behavior-defined engine model with a reusable behavior

Example prompts

  • “Add a shared engine definition for a new CLI agent that installs through npm and supports MCP.”
  • “Does this engine need a dedicated Go implementation, or can behaviors cover it?”

Requirements

  • A checkout of the gh-aw repository

Workflow steps

9 steps, taken from the first numbered list in SKILL.md.

  1. Create .github/workflows/shared/.md.
  2. Declare engine.id, display-name, description, experimental, provider
  3. Pin a default CLI version. Make installation deterministic and provide a
  4. Document setup, authentication, model syntax, MCP support, and limitations
  5. Add the engine ID and shared definition path to
  6. Add .github/workflows/smoke-.md, following the closest existing
  7. Update the unsupported sample table in
  8. Add a changeset when the engine is a user-visible repository sample. New
  9. Run make recompile and include the generated smoke workflow

What it can do on your machine

Read from SKILL.md and the folder at commit eb63040. It shows what the files ask for, not the result of running them.

  • Tool permissions

    Pre-approves nothing: there is no allowed-tools line, so your agent's usual permission prompts apply.

    From allowed-tools in the SKILL.md frontmatter.

  • Runs code

    Shell commands in SKILL.md call:

    • make
    • go

    From the folder's file list and the shell code blocks in SKILL.md.

  • Network

    No URLs in SKILL.md.

    From URLs in SKILL.md, links to its own repository left out.

  • Credentials

    Names no API keys, tokens, secrets or passwords.

    From names ending in _API_KEY, _TOKEN, _SECRET, _KEY or _PASSWORD in SKILL.md.

Context cost

gh-aw Custom Engine Implementation loads about 1.9k tokens when it runs. Until then it costs about 36 tokens; SKILL.md has 844 words of instructions outside code blocks.

Always · name and description, kept in context so the agent knows when to use it
~36
When it runs · the whole SKILL.md, loaded when a task matches
~1.9k

Estimates: characters ÷ 4, the usual rule of thumb; real counts depend on the model's tokenizer. Scripts and assets cost tokens only if the agent reads them.

Safety

Auto-check passed

The automated check found no risky patterns in SKILL.md.

Automated static check — not a guarantee. Review scripts before installing. It scans the text of SKILL.md for risky patterns (piping downloads into a shell, reading credential files, hidden Unicode, destructive commands); files beside SKILL.md are not scanned.

SKILL.md

The full file from github/gh-aw at commit eb63040, republished under its MIT licence (© github). 844 words, ~1,907 tokens.

Download SKILL.mdSave it as .claude/skills/custom-engine-implementation/SKILL.md (or your agent's skills folder).
name
custom-engine-implementation
description
Add and test declarative behavior-defined agentic engines in gh-aw, extending Go infrastructure only when necessary.

Custom Engine Implementation

Use this skill when adding a new agentic engine definition or extending the behavior-defined engine infrastructure.

Choose the smallest implementation

Prefer a shared Markdown engine definition. Installation, execution, MCP configuration, provider routing, caching, manifests, plugins, network defaults, harness scripts, and log parsing can already be declared through engine.behaviors.

Only change Go code when the engine needs a reusable behavior that the declarative model cannot express. Add a dedicated Go engine only when the shared behavior-defined runtime cannot run the engine at all.

NeedImplementation
Existing behaviors are sufficientAdd an imported shared engine definition
A reusable declarative behavior is missingExtend the definition model and behavior-defined runtime
The shared runtime is fundamentally unsuitableAdd a dedicated Go engine and register it

The relevant implementation is in:

  • pkg/workflow/engine_definition.go for the definition model and catalog
  • pkg/workflow/behavior_defined_engine.go for the shared runtime
  • pkg/workflow/engine_definition_loader.go for embedded built-in definitions
  • pkg/workflow/agentic_engine.go for dedicated Go engine registration
  • pkg/parser/schemas/main_workflow_schema.json for the workflow schema

Study representative engines

Read the closest examples before making changes:

  • .github/workflows/shared/opencode.md: npm installation, merged configuration, MCP, provider routing, and log parsing
  • .github/workflows/shared/aider.md: Python installation and a custom harness without native MCP
  • .github/workflows/shared/crush.md: native MCP configuration adapter and harness
  • .github/workflows/shared/cursor.md: plugin support
  • .github/workflows/shared/deepseek-harness.md: provider endpoint discovery and a headless profile

Use the examples to identify a pattern, not as a reason to copy optional behaviors.

Add a shared engine definition

  1. Create .github/workflows/shared/<engine>.md.
  2. Declare engine.id, display-name, description, experimental, provider metadata, authentication, and only the required behaviors.
  3. Pin a default CLI version. Make installation deterministic and provide a verification command.
  4. Document setup, authentication, model syntax, MCP support, and limitations in the Markdown body. Keep in-repository integrations clearly identified as unsupported samples.
  5. Add the engine ID and shared definition path to .github/aw/engines.json. Imported behavior-defined engines are registered dynamically; do not add them to NewEngineRegistry().
  6. Add .github/workflows/smoke-<engine>.md, following the closest existing smoke workflow. Import the shared definition and exercise the capabilities the engine claims to support.
  7. Update the unsupported sample table in docs/src/content/docs/reference/engines.md.
  8. Add a changeset when the engine is a user-visible repository sample. New experimental engines have precedent as a minor change.
  9. Run make recompile and include the generated smoke workflow .lock.yml.

TestKnownEngineImportsFile_MatchesSharedEngineFiles in pkg/workflow/engine_definition_test.go enforces catalog coverage for shared external engines.

Design the definition

Keep the definition declarative and minimal:

  • Select the correct package manager, package name, binary name, version, and verification command under behaviors.installation.
  • Put invocation arguments and non-secret environment variables under behaviors.execution.
  • Use an existing secret strategy and provider environment mode where possible.
  • Declare native MCP support only when the CLI can consume the generated configuration. Otherwise use a harness or the gh-aw CLI proxy pattern.
  • Add only required default domains and map provider-specific domains under behaviors.network.provider-domains.
  • Declare manifest files, cache paths, and plugin support only when the CLI consumes them.
  • Add a log parser only when its emitted event format can be tested.

Treat inline JavaScript in harnesses, configuration adapters, and log parsers as production code. Avoid shell interpolation, validate paths and child-process arguments, preserve nonzero exit codes, and never print secret values. Enabling package lifecycle scripts requires a pinned version and an explicit reason.

For log and error regular expressions, also load .github/skills/error-pattern-safety/SKILL.md.

Show full SKILL.md (314 more words)Show less

Extend declarative infrastructure

When an engine exposes a generally useful capability that existing behaviors cannot express:

  1. Add the smallest field to the types in pkg/workflow/engine_definition.go.
  2. Validate and render it in the focused behavior-defined engine files.
  3. Update pkg/parser/schemas/main_workflow_schema.json.
  4. Add focused tests for parsing, validation, and rendered execution behavior.
  5. Run make generate-schema-docs when generated schema documentation changes.

Do not add a schema field for a behavior that can be represented by existing installation, execution, environment, harness, or adapter fields.

For a dedicated Go runtime, implement the engine interfaces by composing the existing helpers, keep engine-specific code in its own files, and register the engine in pkg/workflow/agentic_engine.go. Cover configuration, commands, environment, authentication, tools, logs, and failure handling with focused tests.

Test the right layers

Use tests that match the changed behavior:

AreaTests and examples
Harness, configuration, MCP, and environmentbehavior_defined_engine_harness_test.go
Log parsingbehavior_defined_engine_log_parser_test.go
Cache behaviorbehavior_defined_engine_cache_test.go
Definitions, catalog, and known importsengine_definition_test.go, engine_catalog_test.go
Embedded definitionsengine_definition_loader_test.go
Real shared workflow harnessaider_workflow_test.go
Sandboxed CLI visibilitycloud_hypervisor_test.go
Generated smoke workflowscompiled_lock_files_test.go

Test both definition parsing and the generated installation/execution steps. Include negative cases for unsafe paths, invalid configuration, missing credentials, or malformed logs when relevant.

Validate

After Go changes:

bash
make build
make fmt

After workflow Markdown changes:

bash
make recompile

Run focused go test commands for the changed behavior while iterating. Before an intermediate progress report, run:

bash
make agent-report-progress-no-test

Before the final progress report, run:

bash
make agent-report-progress

Use make agent-finish for the final repository validation when time allows. Do not trigger a smoke workflow from a Copilot cloud agent run.

Completion checklist

  • The declarative path was preferred unless its limitations are documented.
  • The engine definition uses a pinned, verified installation.
  • Authentication, provider/model handling, MCP, and network access are covered.
  • Harnesses and adapters do not expose secrets or interpolate untrusted input.
  • .github/aw/engines.json, smoke workflow, generated lock file, documentation, and changeset are updated when applicable.
  • Focused tests cover parsing and rendered runtime behavior.
  • Repository validation passes.

© github, MIT. Rendered from Markdown: HTML in the file is shown as text, images as links, and headings moved down two levels. Raw file

Files

Just SKILL.md in .github/skills/custom-engine-implementation of github/gh-aw.

Open the folder on GitHubat commit eb63040

Compare with similar skills

gh-aw Custom Engine Implementation next to the 5 skills that share the most tags, products or categories with it. Stars are the repository's; “used in” counts other GitHub owners with a copy.

gh-aw Custom Engine Implementation compared with similar skills
SkillStarsUsed inTokensAuto-checkLicenceRepo updated
gh-aw Custom Engine Implementation this skillgithub/gh-aw5.3k—~1.9kAutomated safety check: PassMIT
Example Harnessruvnet/metaharness688—~735Automated safety check: PassMIT
Docs Tooling Notionlangchain-ai/docs424—~1.7kAutomated safety check: PassMIT
Prepare Cloudflare Production DeploymentLubomirGeorgiev/cloudflare-workers-nextjs-saas-template786—~5.9kAutomated safety check: NotesMIT
Claude Docs Consultantcentminmod/my-claude-code-setup2.7k—~959Automated safety check: PassMIT
Publishingadeze/raindrop-mcp188—~398Automated safety check: PassMIT

Similar skills

  • Example Harness

    ruvnet/metaharness

    Scaffold a ready-made AI agent harness in one command from the 19 published @metaharness/ example packages — 9 host integrations (Claude Code, Codex, Hermes, pi.dev, OpenClaw, RVM, Copilot…

    688 GitHub stars~735 tokensUpdated today
    DevOps & CloudAuto-check passed

  • Docs Tooling Notion

    langchain-ai/docs

    Official

    Document new or changed docs-team tooling on the Notion tooling pages.

    424 GitHub stars~1.7k tokensUpdated today
    DevOps & CloudAuto-check passed

  • Prepare Cloudflare Production Deployment

    LubomirGeorgiev/cloudflare-workers-nextjs-saas-template

    Source-of-truth runbook for preparing this Vinext Cloudflare Workers SaaS template for production deployment.

    786 GitHub stars~5.9k tokensUpdated today
    DevOps & CloudAuto-check: notes

  • Claude Docs Consultant

    centminmod/my-claude-code-setup

    Consult official Claude Code documentation from code.claude.com using selective fetching.

    2.7k GitHub stars~959 tokensUpdated 9 days ago
    Agent WorkflowsAuto-check passed

  • Publishing

    adeze/raindrop-mcp

    Publishing and release workflow with semantic-release and GitHub Actions

    188 GitHub stars~398 tokensUpdated 2 mo ago
    DevOps & CloudAuto-check passed

  • Review

    apollographql/apollo-mcp-server

    Review a GitHub pull request for a Rust codebase. An agent skill from apollographql/apollo-mcp-server.

    311 GitHub stars~2.9k tokensUpdated today
    Testing & QAAuto-check passed

More from github/gh-aw

All 52 skills in this repo

  • playwright-cli Browser Automation

    github/gh-aw

    Official

    Drives a real browser from the command line with playwright-cli to open pages, interact, mock requests, save state and work with Playwright tests.

    5.3k GitHub starsUsed in 23 repos~2.8k tokens
    Auto-check passed

  • Operational Value Designer

    github/gh-aw

    Official

    Designs and verifies a deterministic grader that measures whether a GitHub Agentic Workflow run reached its real-world or repository outcome.

    5.3k GitHub stars~6.8k tokensUpdated today
    Auto-check passed

  • Copilot Canvas Extension Author

    github/gh-aw

    Official

    Scaffolds, edits, reloads and debugs a canvas extension that the GitHub Copilot CLI can open in its side panel.

    5.3k GitHub stars~3.7k tokensUpdated today
    Auto-check passed

  • GitHub Copilot PR Finisher

    github/gh-aw

    Official

    Drives an open pull request to merge-ready from inside a GitHub Copilot cloud agent, resolving review threads and local checks concurrently, without merging or retriggering CI.

    5.3k GitHub stars~3.8k tokensUpdated today
    Auto-check: warnings

  • gh-aw Firewall Release Integrator

    github/gh-aw

    Official

    Bumps gh-aw's pinned gh-aw-firewall version, rebuilds generated artifacts, and flags upstream spec or schema changes that need follow-up work.

    5.3k GitHub stars~899 tokensUpdated today
    Auto-check passed

  • gh-aw Console Rendering Tags

    github/gh-aw

    Official

    Guide to the console struct tag system in gh-aw: headers, titles, number and cost formats, omitempty, and how structs, slices and maps render in the terminal.

    5.3k GitHub stars~736 tokensUpdated today
    Auto-check passed

Works with

Categories

Questions about gh-aw Custom Engine Implementation

What does gh-aw Custom Engine Implementation do?

Adds and tests declarative, behavior-defined agentic engines in GitHub Agentic Workflows, touching Go infrastructure only when the declarative model falls short. The guiding rule is to choose the smallest implementation.behaviors.

When should I use gh-aw Custom Engine Implementation?

gh-aw Custom Engine Implementation fits situations like: adding a new engine definition to gh-aw; deciding whether an engine needs Go changes or just a shared definition; extending the behavior-defined engine model with a reusable behavior.

How do I install gh-aw Custom Engine Implementation in Claude Code?

Run `npx skills add github/gh-aw --skill custom-engine-implementation -a claude-code`. Or copy the skill folder (.github/skills/custom-engine-implementation in github/gh-aw) into .claude/skills/custom-engine-implementation in your project. Claude Code loads it when a task matches its description.

How do I install gh-aw Custom Engine Implementation in Codex?

Run `npx skills add github/gh-aw --skill custom-engine-implementation -a codex`. Or copy the skill folder (.github/skills/custom-engine-implementation in github/gh-aw) into .agents/skills/custom-engine-implementation in your project. Codex loads it when a task matches its description.

Can I use gh-aw Custom Engine Implementation in Cursor, Gemini CLI or GitHub Copilot?

Cursor, Gemini CLI, GitHub Copilot and OpenCode also load SKILL.md folders. With the skills CLI, run `npx skills add github/gh-aw --skill custom-engine-implementation -a cursor` (or -a gemini-cli, github-copilot or opencode for the others). To copy it by hand, put the folder in .cursor/skills/custom-engine-implementation, .gemini/skills/custom-engine-implementation, .github/skills/custom-engine-implementation and .opencode/skills/custom-engine-implementation in your project.

What does gh-aw Custom Engine Implementation need to run?

Going by SKILL.md and its folder, gh-aw Custom Engine Implementation needs the command-line tools its instructions call (make and go). Our summary lists: A checkout of the gh-aw repository.

Does gh-aw Custom Engine Implementation access the network?

SKILL.md contains no URLs. Any network use would come from the scripts or tools the agent runs. This is read from the text; nothing was executed.

Is gh-aw Custom Engine Implementation safe to install?

Our automated static check of SKILL.md found no risky patterns, such as piping downloads into a shell, reading credential files or hidden Unicode. It is not a guarantee. Review the folder before installing.

What licence does gh-aw Custom Engine Implementation use?

gh-aw Custom Engine Implementation is published under the MIT licence (the repository's licence). It allows redistribution, so the full SKILL.md is shown on this page.

How many tokens does gh-aw Custom Engine Implementation use?

About 1.9k tokens (SKILL.md is roughly 7.6k characters). Agents keep only the skill's name and description in context until a task matches; then they load SKILL.md in full.

What are the alternatives to gh-aw Custom Engine Implementation?

Skills that share tags, products or a category with gh-aw Custom Engine Implementation: Example Harness (ruvnet/metaharness, 688 stars), Docs Tooling Notion (langchain-ai/docs, 424 stars), Prepare Cloudflare Production Deployment (LubomirGeorgiev/cloudflare-workers-nextjs-saas-template, 786 stars) and Claude Docs Consultant (centminmod/my-claude-code-setup, 2.7k stars). The comparison table on this page puts their stars, adoption, token cost, safety result and licence side by side.

Who maintains gh-aw Custom Engine Implementation?

github (a GitHub organization, an official publisher) maintains it in github/gh-aw, which has 5,350 GitHub stars. The repository holds 52 skills in this directory. The repository was last updated on October 7, 2026.

Source: github/gh-aw on GitHub. Facts on this page come from the repository at the commit we read; the author's words are quoted as theirs.