long-running-agent-harness

Long-running agent workflow automation. Initialize project scaffolding, manage feature lists, track progress across sessions, and orchestrate coding agents.

Security Scan

The skill's files, scripts, and runtime instructions are coherent with its stated purpose of orchestrating a long‑running agent harness (it initializes templates, reads/writes progress & feature files, and guides coding sessions); nothing requested is disproportionate or unrelated to that goal.

Purpose & Capability

Name/description (long-running agent harness) match the provided templates, prompts, and scripts. Declared dependencies (bash, git, python3) are reasonable for the operations the harness performs (file templating, git init/commit, small Python snippets). No unrelated credentials, binaries, or external services are required by the skill itself.

Instruction Scope

SKILL.md, prompts, and harness.sh consistently instruct agents to: initialize templates, read/write feature_list.json and claude-progress.txt, run init.sh, inspect git history, perform one feature per session, run end-to-end tests, and commit changes. All of these are within scope for an automation that manages incremental coding sessions. The prompts explicitly tell agents to modify files and run git commands — this is expected but is powerful (it modifies your repository).

Install Mechanism

Instruction-only skill with included scripts and templates; no install spec, no network/downloads, and no archives extracted. Files are shipped with the skill; there is no remote installer or URL-based fetch. This is a low-risk install mechanism.

Credentials

The skill declares no required environment variables or secrets. It uses local tooling (git, bash, python3) appropriate to the task. There are no requests for unrelated credentials or access tokens.

Persistence & Privilege

always: false and disable-model-invocation: false (normal). The harness writes files (.harness.json, feature_list.json, claude-progress.txt, init.sh) and runs git operations (init, commit, checkout/stash guidance). This is appropriate for its purpose but gives the skill the ability to modify the user's repository; users should be aware and supervise runs in critical repos.

Assessment

This skill appears to do what it says: scaffold per-session feature tracking, prompt agents, and run git commits. Important cautions: 1) The harness will create and modify files in whatever directory you run it in and can run git init / git commit — do not run it in a production or important repository without a backup or in a throwaway clone. 2) The provided init.sh is a template that could be customized to run arbitrary commands; review its contents before executing. 3) The coding prompts instruct agents to run tests and use browser automation/curl — ensure required tooling is installed and sandbox any automation you don't trust. 4) The skill expects you to paste prompts to an external Claude agent/service (per README/prompt guidance); be mindful of any data you send there. If you want extra safety, run the harness in an isolated directory, inspect and edit the templates (init.sh, feature_list.json) before use, and keep version control (or a disposable branch) so you can review or revert commits.

Agent Harness Skill

Automates the long-running agent workflow from Anthropic's engineering blog. Manages feature lists, progress tracking, and session orchestration across multiple Claude Code sessions.

Commands

/harness-init <project-description>

Initialize a new project with:

• feature_list.json — comprehensive feature tracking
• claude-progress.txt — cross-session progress log
• init.sh — development server startup script
• .harness.json — harness configuration

/harness-run

Start a coding session. Reads progress, picks the next feature, and follows the incremental development workflow.

/harness-status

Show current project progress: features completed, next features to implement, recent session history.

/harness-feature <description>

Add a new feature to the feature list.

/harness-commit

Commit current work with structured message and update progress file.

Architecture

┌─────────────┐     ┌──────────────┐     ┌──────────────┐
│  Initializer │────▶│  Coding Agent│────▶│   Next Coding│
│    Agent     │     │  Session #1  │     │    Agent #2  │
└─────────────┘     └──────────────┘     └──────────────┘
      │                    │                     │
      ▼                    ▼                     ▼
┌─────────────────────────────────────────────────────────┐
│                    Shared State                          │
│  ┌───────────────┐ ┌──────────────┐ ┌────────────────┐ │
│  │feature_list   │ │claude-progress│ │   Git History  │ │
│  │    .json      │ │    .txt       │ │   (commits)    │ │
│  └───────────────┘ └──────────────┘ └────────────────┘ │
└─────────────────────────────────────────────────────────┘

Workflow

1. Init: harness init "Build a chat app" — sets up project skeleton
2. Code: harness run — each session picks ONE feature
3. Track: Features marked passing only after end-to-end testing
4. Commit: Progress documented in git + progress file
5. Repeat: Continue until all features pass

Key Principles

• Incremental: One feature per session
• Tested: End-to-end testing before marking complete
• Clean state: Always leave codebase merge-ready
• Persistent state: Git + progress file bridge context windows