walkinglabs/learn-harness-engineering
A project-based course repository on making Codex and Claude Code more reliable, centered on an Electron personal knowledge base app with lecture handouts, example artifacts, and practical harness projects.
🛠️ Awesome tools & guides for harness engineering.
This page lists names, links and short descriptions. The original list on GitHub is the source and belongs to its authors.
A project-based course repository on making Codex and Claude Code more reliable, centered on an Electron personal knowledge base app with lecture handouts, example artifacts, and practical harness projects.
A Codex-focused engineering curriculum with installable skills, repository instructions, scoped permissions, testing, review, orchestration, and reproducible token measurements for building an inspectable coding-agent harness.
Trilingual architecture notes and runnable demos covering agent loops, tool execution, memory, permissions, context delivery, and orchestration.
A build-along write-up that grows a TypeScript browser agent from a bare loop that lies about success into a harness with guardrails, context trimming, deterministic trace verification, retries, and harness-handled login, with one branch per step in basically-ai-harness.
OpenAI's flagship field report on building a large application with Codex using architectural constraints, repo-local instructions, browser validation, and telemetry.
Anthropic's core article on initializer agents, feature lists, init.sh, self-verification, and handoff artifacts across many context windows.
Anthropic follow-up focused on improving long-running app generation with better task state and evaluator design.
LangChain's concise framing of an agent as model plus harness, with prompts, tools, middleware, orchestration, and runtime infrastructure.
Thoughtworks' framing of harness work into context engineering, architectural constraints, and "garbage collection" against entropy.
Anthropic's broader guide to workflows, agents, tools, and when structured systems outperform raw prompting.
A practical argument that weak results from coding agents are often harness problems rather than model problems.
Inngest's case for treating state, retries, traces, and concurrency as first-class infrastructure.
A three-way taxonomy of codebases agents encounter — agent-native greenfield, true legacy brownfield, and recently-vibecoded inheritance — with playbooks for installing layered CLAUDE.md rules, ratcheted pre-commit hooks, baselined lint violations, and feature-folder refactors so the codebase…
A position paper that treats the harness layer as a first-class research object, proposes the control–agency–runtime (CAR) decomposition, and introduces HarnessCard for structured reporting of harness design and evaluation.
A handbook framing the layer above the per-agent harness: how multiple harnessed agents share a commons, where decisions belong on a planned / emergent spectrum, and how human stewardship operates at a different cadence than agent execution. Treats harness engineering as a critical layer of…
LangChain's decomposition of what belongs in a framework, a runtime, and a harness.
A survey that treats the agent loop, not the model, as the unit of analysis: loop paradigms, termination and step budgets, verification, context management and recovery, skills, and harnesses, with a chapter on separating harness effects from model effects in evaluation.
Open dataset of 1,256 LLM agent harnesses coded on 38 design dimensions (context, tools, loop, memory, verification, budgets, sandbox, observability), each value backed by a verbatim quote and a file:line@commit locator, so harness designs can be compared and checked against their source.
Anthropic's guidance on managing the context window as a working memory budget rather than a dumping ground.
Manus' detailed playbook on KV-cache locality, tool masking, filesystem memory, and keeping useful failures in-context.
Thoughtworks guidance on shaping the task environment so coding agents can stay grounded and productive.
HumanLayer patterns for reducing context drift and making coding sessions easier to resume.
HumanLayer's ideas for preventing agents from burning context on noisy or low-value work.
OpenHands' design for bounded conversation memory that preserves goals, progress, critical files, and failing tests while keeping long-running coding sessions efficient.
A practical guide to creating durable, repo-local instructions that agents can repeatedly follow.
A context-management methodology that routes only the necessary-and-sufficient context to an agent through a deterministic chain (module registry → wiki → session state), cutting overread and context loss on large, under-documented multi-module codebases.
Indexed Markdown knowledge bases that give agents incremental project context through deterministic indexes, scoped CLI access, and merge handling for parallel edits.
Git-native project knowledge base and MCP server with governed proposal-to-acceptance workflows, validity windows, supersession chains, and retrieval of in-force engineering guidance.
Local-first, source-grounded project memory that preserves verified decisions, Plan state, and source-linked Wiki and code context across coding-agent sessions.
Context database that unifies agent memory, knowledge retrieval, and skills behind an MCP-accessible storage layer.
Developer-alpha encrypted knowledge store that lets harnesses retrieve context and persist task handoffs through scoped, expiring MCP grants.
Derives status and lineage for the plan files coding agents leave behind, so a later session or its operator can tell which plan finished, which replaced which, and find the decisions inside them.
Local-first engineering memory for coding agents, with private session handoffs, reviewed knowledge tied to code citations, and optional Git-backed team sharing.
Anthropic's approach to giving agents controlled execution power through explicit, inspectable tool boundaries.
Anthropic's guidance on tool interfaces that are easier for models to call correctly and safely.
MCP proxy for progressive tool discovery, scope-based allow/block lists, and audit logging, reducing startup context while preventing blocked tools from being discovered or called.
Python runtime whose Guard checks each proposed tool call (tool in the catalog, typed arguments, values quoted from the conversation, policy rules) and allows it, denies it or escalates it to a person, keeping a replayable trace: a fail-closed execution boundary written as code.
Anthropic on reducing approval friction without losing control through better sandboxing and policy design.
OpenHands' practical guide to confirmation mode, analyzers, sandboxing, and hard policies for reducing prompt-injection risk in autonomous coding agents.
Deterministic pre-action authorization hooks for AI-agent tool calls, with adapters for Claude Code, Cursor, OpenClaw, LangChain, CrewAI, and related runtimes.
Open-source local policy checks and human approval for supported coding-agent actions including shell commands, file access, package installs, and MCP tool calls; coverage depends on the agent integration.
Static scanner that runs in CI before deploy to surface AI-agent capability risks, including shadow capabilities, credentials into LLM context, eval/subprocess in @tool, direct prompt interpolation, and unverified MCP endpoints.
Grammar-enforced safety constraints for AI agents via AIL (AI-Intent Language).
Cross-host governance layer that binds intent, evidence, authorization, risk, and acceptance to agent execution, with a portable Skill, inspectable DSH runtime, and published version-scoped paired evaluations.
Commit-time audit harness for AI coding agents: 28 deterministic, zero-token audit rules over Git diffs (secrets, out-of-scope edits, blind modifications, prompt-injection traces), an HMAC-chained tamper-evident audit history, and a DSH plugin family; installable as a GitHub Action or MCP server.
Sourced database of real-world AI agent security incidents, useful as threat-model input for harness boundaries: sandbox escapes, destructive agent actions, prompt injection via repo content and agent-framework CVEs, each flagged for confirmed harm vs. demonstration only.
A concrete pattern for giving a scheduled agent real purchasing authority without real risk: a per-transaction autonomy line, an escalation threshold, a hard lifetime ceiling, and a transaction ledger as the actual enforcement mechanism instead of relying on the model's judgment.
Practitioner guidance on concurrency bounds, decorrelated backoff, circuit breakers, and idempotency for preventing agent retry storms.
Post-incident write-up from a scheduled agent whose lockout check fired while the loop ran 3.5 more days, then a second incident where detection missed entirely; argues for a global action integral, a duration bound, a process exit with a human-cleared sentinel, and tripping on missing success…
Failure taxonomy from a year of unattended coding-agent fleets: eight ways a fleet dies, none of them the model, and the operational discipline they add up to.
Cutting work into tasks is also choosing the concurrency: a design-time file partition ("Owns" lines) serialises overlapping tasks through dependency edges instead of runtime negotiation.
GitHub's toolkit for spec-driven development, useful when you want agents to execute against explicit product and engineering specs.
A repository-centered methodology for preserving product intent, decisions, specifications, evidence, and traceability as durable context while keeping approval authority with humans.
Repo-local requirements linked to code and tests, with checks that help coding agents stay aligned with project intent.
Thoughtworks on why strong specs make AI-assisted software delivery more dependable.
HumanLayer's operating principles for production agents, including explicit prompts, state ownership, and clean pause-resume behavior.
An operations-oriented companion focused on context discipline, validation, and reproducible agent workflows.
Thoughtworks on constraining agents with concrete exemplars so they produce more consistent output.
A clear mental model for where humans should strengthen the harness instead of micromanaging every artifact.
Anthropic's practical recommendations for repo structure, checkpoints, validation, and delegation in agentic coding workflows.
OpenAI's concrete guide to turning agent traces into repeatable evals with JSONL logs and deterministic checks.
OpenHands' hands-on playbook for measuring whether a skill actually helps using bounded tasks, deterministic verifiers, no-skill baselines, and trace review.
OpenAI's product guide for measuring agent quality with reproducible task-level and workflow-level evaluations.
OpenAI's general guide to building eval suites that match real-world distributions and catch regressions early.
OpenAI documentation on grading agent traces directly, which is especially helpful for long multi-step tasks.
UK AISI's open-source evaluation framework with solver, scorer, sandboxing, tool-use, MCP, and log-viewer primitives for building reproducible agent eval harnesses.
Anthropic's guidance on what to measure when agents have many possible trajectories to success or failure.
LangChain's practical breakdown of single-step, full-run, and multi-turn eval design for stateful agents.
Technical report on training agents for changing harnesses, with held-out prompt and Skill edit evaluations that keep model weights fixed and document developer review.
Offline Node.js preflight checks for declared coding-agent write scopes, separate read-only review roles, and handoffs. Produces deterministic failures for inconsistent declarations; runtime enforcement stays with the host.
Thoughtworks on moving quality checks into the loop instead of relying on after-the-fact manual review.
Reviewer for coding-agent workflows that turns repository and session evidence into prioritized, verifiable harness improvements while keeping unobserved behavior explicit.
OpenHands' overview of a layered verification stack using trajectory critics trained on production traces for reranking, early stopping, and review-time quality control.
LangChain's evidence that harness changes alone can significantly improve benchmark performance.
A public audit log of one agent's real task in which every conclusion carries a runnable command and the record keeps the agent's own four bugs, one false positive, and one false discovery it caught itself: a concrete reference for making an agent's claims checkable by a third party and its…
CI harness that records an agent's tool calls once and replays them in CI, so a PR fails when tool order or a JSON-schema contract breaks, a tool-call budget is exceeded, or a baseline regresses; emits JUnit and HTML reports. This makes harness verification a merge gate.
An agent reporting "done" is the actor grading its own work; the cheap guard is an independent observer — a second agent, a separate tool, or the live artifact — spawned interactively and as a validation gate in a fleet.
Standard span, metric, event, and attribute conventions for instrumenting LLM and agent workflows so harness traces stay portable across observability backends.
Open-source Python SDK for agent monitoring, session replay, cost tracking, benchmarking, and tracing across common LLM and agent frameworks.
Local-first TUI/CLI for auditing AI coding-agent session traces, health gates, cost spikes, tool failures, latency gaps, and attempt-to-attempt diffs.
Profiling and optimization toolkit for agents: bounded CLI and MCP workflows capture traces, preserve native evidence, and compare experiments behind runtime conclusions.
Local-first telemetry and memory graph for auditing coding-agent sessions, costs, skills, tool usage, and OTLP events across multiple agent runtimes.
Apache-2.0 OpenTelemetry instrumentation for 50+ AI frameworks across Python, TypeScript, Java and C# that records LLM calls, tool calls, retrieval and agent steps as standard spans, so harness traces stay portable to any OTel backend.
Anthropic on how runtime configuration can move coding benchmark scores by more than many leaderboard gaps.
A benchmark write-up on evaluating agents across dependent milestone sequences from real repository history, surfacing regression accumulation and long-horizon precision loss.
The Terminal-Bench 2.0 announcement, useful for understanding the harder tasks and generalized evaluation harness behind Harbor.
An RL environment interface to LeetCode's submission server for evaluating codegen agents, giving harnesses direct access to execution-based feedback on hard algorithmic problems.
A benchmark for evaluating LLM agents on real-world software security tasks including vulnerability reproduction and patching, stressing harness design around code execution, containerized environments, and security-aware tooling.
A strong benchmark for software engineering agents working against real GitHub issues and tests, which makes harness choices around retrieval, patching, and validation highly visible.
A benchmark suite for terminal-native agents operating in shells, filesystems, and verification-heavy environments, which is especially useful for comparing coding-agent harnesses.
Open benchmark for evaluating models as runtime Controllers around a separate, fixed coding Worker. Paper · ModelScope
An integrated benchmark suite with realistic environments and comprehensive toolkits for evaluating virtual agents on real computer software, useful for measuring harness depth against a broad task surface.
A benchmark that evaluates web agents on realistic, time-consuming research tasks requiring multi-step tool use and information synthesis, making it a good proxy for harness quality in long-horizon web scenarios.
A benchmark that evaluates AI agents on locating hard-to-find information, stressing search strategy, context management, and retrieval harness design under difficult conditions.
A gym environment and leaderboard for evaluating LLMs, VLMs, and agents on web navigation tasks, offering a reproducible framework for comparing harnesses across multiple web benchmarks in one place.
A browser-agent benchmark of 153 everyday web tasks across 144 live production sites in 15 categories, using a lightweight interception layer that captures and blocks only the final submission request so agents can be scored end-to-end on real websites without real-world side effects.
An open evaluation platform where users compare LLM/VLM-based agents on real-world computer tasks ranging from general computer use to coding, data analysis, and video editing, surfacing harness differences across a wide task surface.
A real computer-use benchmark with 369 tasks across Ubuntu, Windows, and macOS, complete with initial-state setup and execution-based evaluators, making it excellent for testing desktop and multimodal harnesses.
An extension of OSWorld that evaluates AI agents on real-world computer tasks using the Model Context Protocol, making it useful for comparing MCP-enabled harnesses on a realistic desktop task suite.
VisualAgentBench evaluates large multimodal models as visual foundation agents across embodied, GUI, and visual design tasks, useful for comparing harnesses on visually grounded, multi-step agent workflows.
A benchmark for multimodal web agents on realistic visually grounded tasks, extending WebArena with image and screenshot inputs that stress harness support for visual context in browser environments.
A standalone, self-hostable web environment for evaluating autonomous agents on realistic tasks, making it a reproducible baseline for comparing web-facing harness designs.
A verified web-agent benchmark with curated tasks and deterministic evaluators over agent responses and captured network traces, making it a good fit for measuring web-facing harnesses.
Website reconstruction tasks with native Harbor configurations and a separate no-network verifier for checking coding-agent implementations.
A benchmark for browser agents on common knowledge-work tasks, useful for comparing harnesses on realistic enterprise-style web workflows instead of toy browser tasks.
A cross-environment benchmark spanning OS, databases, knowledge graphs, web browsing, and more, useful for seeing whether a harness generalizes beyond one narrow task loop.
A controllable world of apps and people for benchmarking interactive coding agents, with state-based and execution-based unit tests that surface harness quality around planning, code generation, and collateral-damage control.
A benchmark that evaluates the tool-use capability of LLM-based agents using human-written queries, real deployed tools, and authentic multimodal inputs, exposing harness gaps between isolated testing and real deployment.
A benchmark for evaluating AI models on MCP server interactions, measuring tool accuracy, latency, and token use across server types, which directly reflects harness design choices around MCP integration.
A leaderboard comparing AI model performance on MCP tasks, tracking how different models and harness configurations handle tool-augmented agent workflows.
A stress-testing benchmark for model and agent capabilities in real-world MCP tasks across tools like Notion, GitHub, and PostgreSQL, making harness MCP integration quality directly measurable.
A benchmark that emulates dynamic conversations between a simulated user and a language agent equipped with domain-specific API tools and policy guidelines, making it useful for evaluating harnesses built around structured tool use and policy enforcement.
A benchmark for realistic, multi-step agent tasks where success depends on tool use and execution quality rather than a single-shot answer.
A benchmark for evaluating LLM agents on tool use and complex planning within multiple constraints, revealing how harness design handles multi-constraint satisfaction and long-horizon planning.
Source code for the Gorilla project’s agent comparison platform, including its evaluation and leaderboard frontend; the original hosted leaderboard is currently unavailable.
A benchmark for multi-turn LLM agents complemented by an analytical evaluation board for assessing model performance beyond final success rates, making partial-progress and trajectory quality visible.
A benchmark for evaluating role-playing conversational agents using multi-turn dialogues and character profiles, with metrics across four dimensions including character fidelity and conversational coherence.
A benchmark that evaluates AI agents across search, reasoning, coding, safety, and multi-turn conversation tasks, covering the breadth of harness demands in a single suite.
A benchmark for general AI assistants that is often used to compare harness-level choices around tools, planning, verification, and long-horizon autonomy.
An open evaluation platform tracking LLM agents on task completion and tool calling across business domains, useful for comparing harness quality in enterprise-grade agentic scenarios.
A benchmark and leaderboard for agent systems with attention to reliability, cost, and broad task coverage, making it useful for comparing end-to-end harness behavior.
A platform that evaluates LLMs by having them fight in Street Fighter III, testing speed, adaptability, and real-time decision-making as proxies for harness responsiveness under tight latency constraints.
A benchmark measuring cognition, adaptability, rationality, and collaboration of LLMs in multi-agent systems, useful for evaluating how harnesses coordinate agent interactions and shared state.
An in-the-wild benchmark running agents inside a live OpenClaw environment on 60 original tasks including multimodal, long-horizon, and safety-critical scenarios, making harness robustness under real-world conditions directly visible.
A real-world economic benchmark where AI agents complete professional tasks spanning 44 occupations, earning income while managing token costs and economic solvency, making it a direct test of harness efficiency under resource constraints.
Anthropic's guide to a production-oriented agent SDK with sessions, tools, and orchestration support.
Inngest's TypeScript toolkit for building durable, workflow-aware agents on top of event-driven infrastructure.
Apache-2.0 agent runtime with persistent sessions, governed MCP tools, credential handling, audit and replay, and interchangeable local or sandboxed execution backends.
Cross-platform desktop host for DeepSeek Harness with health probes, restart backoff, collision-free ports, and whole-process-tree cleanup.
Apache-2.0 model router with cross-protocol routing, MCP gateway, guardrails, observability, virtual keys, and multi-account failover.
GPL-3.0 Rust inference-control prototype exploring runtime boundaries, governed memory and replay, evidence-based writer gates, audit traces, and rollback for self-evolving agent systems.
Apache-2.0 drop-in proxy for the Anthropic, OpenAI and Gemini APIs that sits under harnesses like Claude Code, Codex, opencode and pi and picks the model for each request with an on-box embedder; self-hostable, BYOK, OTLP traces.
Apache-2.0 agent-loop engine behind a stateless HTTP API: the harness owns history, approvals, and billing, while write tools return deferred intents, so mutations wait for the harness to approve them.
Model-mediated coding-agent workflow for database-backed applications, combining deterministic domain-model evaluation and repair, typed code generation, and evidence-backed build/test verification.
LangChain's open-source project for building deeper, longer-running agents with middleware and harness patterns.
A mature research coding agent that makes the harness, prompt, tools, and environment design directly inspectable.
A harness for Claude Code and OpenAI Codex with isolated worktrees, multi-agent coordination, and persisted memory and campaign state.
Claude Code plugin that autonomously evolves LLM agent harnesses using multi-agent proposers, LangSmith-backed evaluation, and Git worktree isolation. Based on Meta-Harness (Lee et al., 2026).
Geoffrey Huntley's write-up of "Ralph," a minimalist while :; do cat PROMPT.md | claude-code; done harness pattern that uses single-task loops, deterministic prompt stacking, and bounded subagent parallelism to drive long-running autonomous coding.
Deterministic control plane for multi-agent software work with dependency-aware packages, isolated worktrees, durable validation evidence, recovery checkpoints, and integration gates.
Reproducible OpenCode harness with role-based agents, explicit handoffs, repo-local skills, safe installation, and mechanical contract validation.
Local-first GUI harness for long-running coding work with multi-model planning, isolated worktrees, and fresh-context recovery loops.
Headless coding-agent harness for asynchronous runs with explicit terminal states, editable lifecycle hooks, permission gates, model routing, and append-only traces.
Claude Code plugin harness with a default-fail evaluator, deterministic write and close gates, orphan recovery, and parallel-worker integration checks.
Claude Code plugin for adversarial validation, source-grounding audits, session-learning capture, and pre-deployment transfer simulation.
Command-line harness that runs coding agents (Claude Code, Codex, Gemini CLI) across isolated task worktrees, with a Kanban task lifecycle, review gates, and typed merge and release-readiness boundaries.
MIT-licensed coding agent built on pi that hands routine harness decisions (tool-output admission, stale-context forgetting, command risk, prompt-injection screening, completion checks) to a small judge model as bounded questions, with per-decision active/shadow/off modes and a ledger of every…
Issue-driven harness on top of the Pi coding agent: each labelled GitHub issue runs in an isolated worktree, a separate review session must pass the exact commit before it merges, and all run state lives in issues, labels and PRs so a restart resumes the same run.
Desktop-first, open-source (MIT) application for running parallel agents, and multi-step custom workflows triggered by schedules, webhooks or events from tools like Linear and Sentry, across your already-used providers.
Apache-2.0 terminal harness in Rust that writes every model reply, tool call, permission decision and tool result to a plain-text JSONL transcript, and runs project-declared validator commands in a loop, feeding failures back to the model until they pass or an iteration limit is reached;…
MIT terminal harness whose unit of continuity is one long-lived agent life rather than a task-scoped session: cognition runs without user input, sleep/wake persists unfinished work and deliveries, and user input preempts in-flight parallel work.
Inspectable MIT-licensed Go coding-agent harness with full-history requests, untruncated tool results, resumable JSONL sessions, and a reproducible lossless proof suite.
Anthropic's architecture write-up for a multi-agent system with separation of roles and structured coordination.
MIT-licensed coordination protocol for coding agents across Claude Code, Codex, Cursor, Gemini CLI, and Grok Build, with explicit work claims, edit-overlap detection, durable messages, ownership transfer, and evidence-bearing handoffs exposed through five MCP workflow tools.
Local-first desktop harness for coordinating multiple agents with shared files, independent work contexts, human approval gates, and resumable execution.
Local-first agent operation environment that composes specialist teams while retaining host-local tools, permissions, memory boundaries, and verification rules.
MIT-licensed declarative runtime for multi-agent workflows defined in HCL, including orchestration, state, dependency resolution, routing, persistence, and resume.
MIT-licensed multi-agent software-development workflow with specialized roles and a staged pipeline from requirements through delivery.
MIT multi-agent harness that uses the OS as its control layer: each coding-agent CLI (Claude Code, Codex, Hermes and others) runs as its own Linux user and systemd service, and agents hand off work through one bash CLI and a shared SQLite task queue.
MIT-licensed coordination layer for coding-agent harnesses, with hook-driven messaging, activity observation, agent spawning, and event subscriptions across terminals.
Apache-2.0 host agent that plans complex tasks as DAGs and orchestrates built-in and third-party agents such as Claude Code and Codex over ACP, CLI, or OpenAI-compatible APIs; its agent loop is split into Memory, Planning, Capability, and Action strategy modules that an experimental Curator…
A thin CDP-based browser harness that lets agents extend helper functions during execution, useful for inspecting self-healing web-task workflows.
Apache-2.0 WPE WebKit runtime that gives an agent harness one isolated browser session per container, an ordered JSONL execution boundary, native input, semantic and visual evidence, and a reproducible offline acceptance check.
Universal CLI hub connecting agents to 134 sites and desktop apps via 711 declarative YAML pipelines. Ships an 8-phase Karpathy-style self-repair loop, eval harness with a starter catalog, per-call cost ledger, hardcoded sensitive-path deny list, and unicli mcp serve that auto-registers one MCP…
Inspectable runtime boundary for exposing a local agent or automation as a keyed LAN capability with target verification, bounded conversations, JSON output, and explicit exit codes.
Open-source browser automation layer for agents with isolated parallel sessions, multi-account operation, and human handoff when automation is blocked.
Public harness-migration reference for Claude Code to Codex moves, with installable auditor artifacts and explicit validation notes for hooks, MCP config, and instruction-file differences.
A community marketplace for discovering, sharing, and installing reusable AI agent skills across runtimes like Claude Code and OpenClaw, making harness capabilities portable and composable.
Agentic product-workflow harness with Shape Up boundaries, adversarial plan review, acceptance-based execution contracts, and audit loops.
Apache-2.0 visual canvas for agent harnesses that compiles a runtime-neutral FlowSpec to several orchestration frameworks.
Reproducible lifecycle for coding-agent assets with authority-ranked discovery, pinned mirrors, quarantine routing, staged activation, and host-specific wiring.
Codex CLI and Desktop profile launcher that isolates authentication, configuration, sessions, connectors, plugins, and logs by CODEX_HOME.
Git-native workflow-control harness that stores task records, policy, verification evidence, and closure state as reviewable repository artifacts.
Repo-local task ledger and finish gate for Claude Code and Codex sessions: tasks, ownership and check evidence live in plain Markdown files, and SessionStart and Stop hooks check each session in and flag unrecorded work, stale or missing check results, and uncommitted changes before it ends.
MIT Claude Code mod that scopes a global harness per repo: named profiles in ~/.claude decide which skills, agents, instruction files and tools each repo loads, with no network requests or model calls.
hesreallyhim/awesome-claude-code
A hand-picked collection of the finest of resources for the most awesome of agents, Claude Code, the undisputed champion of coding companions, from the unstoppable team…
VoltAgent/awesome-agent-skills
A curated collection of 1000+ agent skills from official dev teams and the community, compatible with Claude Code, Codex, Gemini CLI, Cursor, and more.
EthicalML/awesome-production-machine-learning
A curated list of awesome open source libraries to deploy, monitor, version and scale your machine learning
analysis-tools-dev/static-analysis
⚙️ A curated list of static analysis (SAST) tools and linters for all programming languages, config files, build tools, and more. The focus is on tools which improve…
YouMind-OpenLab/awesome-nano-banana-pro-prompts
🍌 World's largest Nano Banana Pro prompt library — 10,000+ curated prompts with preview images, 16 languages. Google Gemini AI image generation. Free & open source.
ossu/computer-science
🎓 Path to a free self-taught education in Computer Science!