Skip to content
/

AI Engineering Harness

adrielp-ai-engineering-harness · adrielp/ai-engineering-harness · ★ 16 · last commit 2026-05-15

Translates a shared set of context-engineering patterns into native formats for 4 different AI coding tools via a Deno CLI installer.

Best whenContext quality before coding determines output quality — thoughts/ as structured pre-coding knowledge is the real harness.
Skip ifHorizontal test slicing (all tests then all impl), Testing implementation details rather than behavior
vs seeds
openspec(mirror commands + skills, multi-tool portability) but uses a Deno installer CLI for format translation at install time.…
Primitive shape 31 total
Commands 10 Skills 15 Subagents 6
00

Summary

adrielp AI Engineering Harness — Summary

AI Engineering Harness by adrielp is a multi-tool context engineering framework that distributes a shared set of agents, skills, and commands across Claude Code, OpenCode, Gemini CLI, and Pi via a Deno-based CLI installer (ai-harness). The framework's primary innovation is format translation: the same logical commands and agents are rendered in the correct format for each target tool (Claude Code .claude/skills/, OpenCode .config/opencode/, Gemini CLI TOML, Pi prompts/). It ships 25 skills/commands including a notable OpenTelemetry-focused cluster (otel_instrument orchestrator + 5 specialized OTel sub-skills) and TDD/worktree/codebase-research workflows. Six specialized agents (codebase_analyzer, codebase_locator, codebase_pattern_finder, thoughts_analyzer, thoughts_locator, web_search_researcher) are shared across all tools. The thoughts/ directory pattern is its distinctive innovation: structured context for tickets, plans, and research, separated by person (thoughts/<username>/) and topic. Differs from seeds: closest to openspec (Archetype 2: mirror commands + skills per tool) but adds multi-tool format translation and a dedicated Deno CLI installer, making it the only framework in this batch whose install-time tooling is itself a named CLI binary.

01

Overview

adrielp AI Engineering Harness — Overview

Origin

GitHub: https://github.com/adrielp/ai-engineering-harness
Stars: 16
License: Apache-2.0
Language: TypeScript (Deno)
Last commit: 2026-05-15

Philosophy

From README:

"A harness for AI coding agents that provides context engineering patterns, commands, and configurations. Install once and instantly configure Claude Code, OpenCode, and Gemini CLI with battle-tested prompts, agents, and workflows."

The framework philosophy is "context engineering" — the belief that the quality of AI coding output is determined by the quality of the context provided before coding begins. The thoughts/ directory system represents this: a structured knowledge base of tickets, plans, and research that agents can read.

Key Design Decisions

  1. Format translation: the same logical skill/command is rendered differently for each tool.
  2. GNU Stow support: repo-mode install uses symlinks for easy git pull updates.
  3. Safe re-run: unchanged files are skipped, modified files show diff + confirm.
  4. Deno over Node: the CLI uses Deno for zero-install potential (npx deno fallback).
  5. thoughts/ as first-class artifact: personal and shared context directories, template-driven.
  6. OpenTelemetry cluster: the otel_instrument orchestrator is an unusual specialization for observability-driven development.
02

Architecture

adrielp AI Engineering Harness — Architecture

Distribution

Deno-based CLI installer with multiple install paths:

# Register CLI (one-time)
deno install -Agf -n ai-harness \
  https://raw.githubusercontent.com/adrielp/ai-engineering-harness/main/install.ts

# Install for specific tool
ai-harness --tool=claude          # → ~/.claude/
ai-harness --tool=opencode        # → ~/.config/opencode/
ai-harness --tool=gemini          # → ~/.gemini/
ai-harness --tool=pi              # → ~/.pi/agent/
ai-harness --tool=all             # All four

# Flags
ai-harness --tool=claude --dry-run        # Preview changes
ai-harness --tool=claude --interactive    # Pick components
ai-harness --tool=claude --skill=agents   # Specific component

Directory Tree

ai-engineering-harness/
├── claude/
│   ├── agents/            # 6 shared agent definitions (.md)
│   ├── skills/            # 25 skills/commands
│   ├── settings.json      # Claude Code settings
│   └── .mcp.json          # MCP server config
├── gemini/                # Gemini CLI format (TOML)
├── opencode/              # OpenCode format
├── pi/                    # Pi agent format
├── install.ts             # Deno installer CLI
├── manifest.json          # Component manifest
├── setup.sh               # GNU Stow setup script
└── CLAUDE.md / AGENTS.md  # Project memory

Required Runtime

  • Deno (or npx deno) for CLI installer
  • Target tools: Claude Code, OpenCode, Gemini CLI, Pi

Install Complexity

Multi-step (one-time CLI registration + install command per tool).

Re-run Safety

Unchanged files skipped. Modified files show diff + confirmation prompt.

03

Components

adrielp AI Engineering Harness — Components

Agents (6, shared across all tools)

Name Purpose
codebase_analyzer Analyzes implementation details and traces data flow
codebase_locator Finds files and components by feature/topic
codebase_pattern_finder Discovers similar implementations and patterns
thoughts_analyzer Extracts insights from research documents in thoughts/
thoughts_locator Discovers documents in the thoughts/ directory
web_search_researcher Researches information from web sources

Skills / Commands (25)

Name Type Purpose
init_harness manual Initialize harness: run /init, create thoughts/ structure
create_plan manual Create implementation plan from ticket
implement_plan manual Execute approved plan
validate_plan manual Verify implementation
commit manual Create well-structured git commits
debug manual Investigate issues during testing
debug-k8s manual Debug Kubernetes clusters (prefers K8s MCP)
research_codebase manual Comprehensive codebase research
validate_telemetry manual Validate local telemetry against a narrative spec
worktree manual+auto Manage git worktrees for parallel development
git-commit-helper auto Triggers on "commit these changes"
pr-description-generator auto Triggers when creating PRs
experimental-pr-workflow auto Formalizes experimental work into tickets/PRs
interview auto Stress-test plans via relentless user interview
improve-codebase-architecture auto Find architectural friction, propose deep-module refactors
prd-to-issues auto Break a PRD into vertical-slice issue files
tdd auto Red-green-refactor TDD discipline
write-a-prd auto Generate a PRD from a client brief
otel_instrument auto OTel orchestrator (routes to specialized sub-skills)
otel_collector auto OpenTelemetry collector configuration
otel_instrumentation auto Code instrumentation guidance
otel_ottl auto OTTL pipeline authoring
otel_semantic_conventions auto OTel semantic convention enforcement
observability-driven-development auto ODD methodology guidance
github-tracker auto GitHub issue/PR tracking

Config Files

  • claude/settings.json — Claude Code permissions and hooks config
  • claude/.mcp.json — MCP server configuration
  • manifest.json — component manifest for installer

Format Translation

Component Claude Code OpenCode Gemini CLI Pi
Skills .claude/skills/*/SKILL.md skills/ TOML prompts/*.md
Commands .claude/skills/ with disable-model-invocation: true commands/ TOML prompts/*.md
Agents .claude/agents/*.md agents/ TOML prompts/*.md
05

Prompts

adrielp AI Engineering Harness — Prompts

Excerpt 1: init_harness SKILL.md

Technique: Conditional state-check before action (idempotent initialization)

## What This Command Does
1. Runs the built-in `/init` command to generate `CLAUDE.md`
2. Creates the `thoughts/` directory structure for context engineering
3. Adds a ticket template for consistent ticket creation
4. Provides guidance on next steps

## Instructions
1. **Check the current state of the repository**
   - Verify if `CLAUDE.md` already exists
   - Check if thoughts/ directory exists

2. **Run /init to generate CLAUDE.md** (Claude Code's built-in command)
   - This analyzes the codebase and generates project memory

3. **Create the thoughts/ directory structure**:
   mkdir -p thoughts/shared/{tickets,plans,research}
   mkdir -p thoughts/global

Excerpt 2: TDD SKILL.md — anti-horizontal-slicing rule

Technique: Named anti-pattern with concrete counter-example

## Anti-Pattern: Horizontal Slices

**DO NOT write all tests first, then all implementation.** This is "horizontal slicing"...

**Correct approach**: Vertical slices via tracer bullets. One test → one implementation → repeat.

WRONG (horizontal):
  RED:   test1, test2, test3, test4, test5
  GREEN: impl1, impl2, impl3, impl4, impl5

RIGHT (vertical):
  RED→GREEN: test1→impl1
  RED→GREEN: test2→impl2
  RED→GREEN: test3→impl3

Excerpt 3: TDD SKILL.md — interface-first philosophy

Technique: Explicit philosophy statement + rationale

## Philosophy
**Core principle**: Tests should verify behavior through public interfaces, not implementation details. Code can change entirely; tests shouldn't.

**Good tests** are integration-style: they exercise real code paths through public APIs. They describe _what_ the system does, not _how_ it does it.

**Bad tests** are coupled to implementation. They mock internal collaborators, test private methods...
09

Uniqueness

adrielp AI Engineering Harness — Uniqueness

differs_from_seeds

Closest to openspec (Archetype 2: mirror commands + skills, multi-tool portability) but openspec is npm-distributed while this uses a Deno installer CLI with format translation at install time rather than at runtime. Also resembles spec-kit (explicit command/skill pairs with TDD discipline) but spec-kit is Python-based and Claude Code-only. Unlike any seed, this framework targets 4 different AI tools (Claude Code, OpenCode, Gemini CLI, Pi) and uses the installer to transform a single component definition into each tool's native format. The thoughts/ directory pattern is not present in any seed — it provides structured multi-person knowledge management as a first-class artifact.

Most Distinctive Features

  1. Multi-tool format translation at install time — no seed does this.
  2. OpenTelemetry specializationotel_instrument orchestrator with 4 specialized OTel sub-skills is a unique domain specialization.
  3. thoughts/ personal/shared separation — knowledge management pattern not present in any seed.

Observable Failure Modes

  1. Deno requirement: Deno is less common than Node.js — teams may need to install it.
  2. Low stars: 16 stars suggests minimal community validation.
  3. No hooks: no lifecycle event hooks means no automatic enforcement.
  4. Format drift: maintaining 4 format translations manually requires discipline; the installer is one-directional.
04

Workflow

adrielp AI Engineering Harness — Workflow

Phases

Phase Command/Skill Artifact Gate
Initialize /init_harness CLAUDE.md + thoughts/ structure none
Research research_codebase thoughts/ documents none
Plan /create_plan thoughts//plans/.md none
Interview interview skill stress-tested plan none (auto-trigger)
Implement /implement_plan code + tests plan must exist
Validate /validate_plan validation report none
Commit /commit git commit none
PR pr-description-generator PR description none (auto-trigger)

TDD Workflow (via tdd skill)

Red-green-refactor loop:

  1. Confirm interface changes needed
  2. Confirm which behaviors to test
  3. Write test first (one test → one implementation)
  4. Red → Green → Refactor cycle
  5. Repeat vertically (not horizontally)

OpenTelemetry Workflow

The otel_instrument orchestrator auto-activates on observability/telemetry requests and routes to:

  • otel_collector (collector config)
  • otel_instrumentation (code instrumentation)
  • otel_ottl (OTTL pipelines)
  • otel_semantic_conventions (standards enforcement)

Approval Gates

No explicit user-facing gates. The interview skill functions as a pre-implementation challenge gate.

thoughts/ Directory Convention

thoughts/
├── shared/
│   ├── tickets/      # Tickets shared across team
│   ├── plans/        # Implementation plans
│   └── research/     # Research documents
├── global/
│   └── ticket-template.md
└── <username>/
    ├── tickets/
    ├── plans/
    └── research/
06

Memory Context

adrielp AI Engineering Harness — Memory & Context

State Storage

File-based, project-scoped:

  • thoughts/shared/ — shared plans, tickets, research (team-readable)
  • thoughts/<username>/ — personal plans, tickets, research
  • thoughts/global/ — templates and conventions
  • CLAUDE.md — project memory (generated by /init)

Memory Type

File-based. The thoughts_analyzer and thoughts_locator agents provide structured access to the research documents.

Context Engineering

The thoughts/ directory is the primary context-engineering innovation: it creates a structured knowledge base that agents read before coding, providing the architectural blueprint and domain knowledge that LLMs need for production-quality output.

Cross-Session

All state persists in thoughts/ files. New sessions can read prior research, plans, and tickets.

07

Orchestration

adrielp AI Engineering Harness — Orchestration

Multi-Agent

Yes. The 6 named agents are spawned via the Task tool (Claude Code) or equivalent for other clients. The otel_instrument orchestrator routes to specialized OTel sub-skills.

Orchestration Pattern

task-decomposition-tree: the plan-driven workflow decomposes implementation into tasks. The otel_instrument orchestrator uses sequential routing to specialized sub-skills.

Isolation Mechanism

git-worktree: the worktree skill manages git worktrees for parallel development.

Multi-Model

No.

Execution Mode

Interactive-loop: skill-driven workflow via slash commands.

Cross-Tool Portability

High: format-translated to 4 different AI coding tools. The installer handles translation at install time.

08

Ui Cli Surface

adrielp AI Engineering Harness — UI & CLI Surface

Dedicated CLI Binary

Yes. ai-harness is the Deno-based installer CLI.

It IS a thin wrapper over Deno's module system — it is NOT an agent runtime. Its function is install-time only.

Binary name: ai-harness

Subcommand/Flag Action
--tool=claude Install Claude Code config
--tool=opencode Install OpenCode config
--tool=gemini Install Gemini CLI config
--tool=pi Install Pi agent config
--tool=all Install all tools
--dry-run Preview changes without writing
--interactive Pick components interactively
--skill=<name> Install specific component only

Local UI

None.

GNU Stow Mode

./setup.sh claude installs via symlinks — running git pull updates configs automatically.

Observability

None beyond dry-run preview and diff-on-change output.

Related frameworks

same archetype · same primary tool · same memory type

claude-mem (thedotmack) ★ 78k

Background worker service captures every tool call as an observation, AI-compresses sessions, and auto-injects relevant past…

pi (badlogic/earendil) ★ 55k

A minimal, hackable, multi-provider terminal coding agent that adapts to your workflows via npm-installable TypeScript Extensions…

Agent Skills (Addy Osmani) ★ 46k

Encodes senior-engineer software development lifecycle as 23 auto-routed skills and 7 slash commands for any AI coding agent.

wshobson/agents Plugin Marketplace ★ 36k

Single Markdown source for 83 domain-specialized plugins that auto-generates idiomatic artifacts for five AI coding harnesses.

TabbyML/Tabby ★ 34k

Self-hosted AI coding assistant server (alternative to GitHub Copilot) with admin dashboard, RAG-based completions, and multi-IDE…

Compound Engineering ★ 17k

Make each unit of engineering work compound into easier future work via brainstorm→plan→execute→review→learn cycles.