Source notes and associations
Reviewed on 2026-07-13. These notes explain what each source contributes and how the sources reinforce or qualify one another. They are summaries, not substitutes for current product documentation.
For the complete article-by-article review, use the source dossiers. For proposed policy derived from the combined evidence, use candidate standards.
Association map
Repository knowledge and large-codebase navigation
Sources: Claude large codebases and Harness engineering.
Use a small root map, scoped knowledge, focused discovery, and repository-local sources of truth.
Context and cost
Sources: Claude costs, Claude large codebases, Shell, skills, and compaction, and Codex agent loop.
Reduce always-on instructions and noisy reads, then compact long histories while preserving durable state.
Skill design and evaluation
Sources: Claude skills, OSS maintenance skills, and Shell, skills, and compaction.
Skills need narrow contracts, precise routing metadata, progressive disclosure, negative cases, and separate routing and output evaluations.
Packaging and central ownership
Sources: Claude plugins, Claude large codebases, and OSS maintenance skills.
Keep local workflows near code; package shared capabilities with namespacing, ownership, versioning, and a controlled update path.
Deterministic automation
Sources: Claude hooks, Claude costs, and OSS maintenance skills.
Use hooks and scripts for narrow mechanics, native controls for authority, and skills for judgement and reviewable evidence.
Evidence-producing autonomy
Sources: Harness engineering and OSS maintenance skills.
Require baseline, reproduction, fix demonstration, verification, feedback handling, and judgement escalation before end-to-end autonomy.
Agent runtime architecture
Sources: Codex agent loop, Codex App Server, and Shell, skills, and compaction.
Treat tools, state, events, approvals, artifacts, compaction, and reconnects as first-class harness concerns.
Quality at higher throughput
Sources: Harness engineering and OSS maintenance skills.
Match increased generation capacity with automated review, architecture enforcement, observability, and cleanup.
Product customization and file layout
Sources: OpenAI Codex customization, OpenAI skills, OpenAI plugins, OpenAI hooks, Claude skills, Claude plugins, and Claude hooks.
Share the workflow intent and deterministic scripts, but keep client-specific discovery, trust, permissions, hook events, and manifests explicit.
Article notes
OpenAI: Codex customization documentation
Adds the current product-level implementation missing from the original blog
set: .agents/skills, agents/openai.yaml, .codex/config.toml, Codex hooks,
experimental command rules, .codex-plugin/plugin.json, repository
marketplaces, MCP configuration, and subagents. It confirms that the OpenAI
surfaces are composable but have distinct responsibilities and trust behavior.
The main setup guides use this documentation for exact file placement while the
blog posts continue to provide workflow and harness rationale.
Anthropic: Set up Claude Code in a monorepo or large codebase
Contributes concrete scoping mechanisms: launch-directory semantics, layered instructions, exclusions, code intelligence, sparse worktrees, cross-directory access, nested skills, and centralisation into plugins when local layering no longer scales. It supplies product-specific implementation detail for the broader “map plus on-demand knowledge” model in Harness engineering.
Anthropic: Manage costs effectively
Frames cost primarily as a context-size problem and recommends proactive context management, model selection, reduced tool overhead, code intelligence, hooks, skills, focused prompts, and bounded delegation. Its strongest association is with large-codebase scoping: irrelevant instructions, file reads, tool schemas, and output all consume the same practical budget.
Anthropic: Extend Claude with skills
Defines skills as on-demand instruction packages with scoped locations, supporting files, invocation controls, dynamic context, isolation options, and evaluations. It distinguishes “did the skill trigger?” from “did it perform?” and recommends fresh-session comparisons. The OSS maintenance article shows these principles operating in real repositories.
Anthropic: Create plugins
Shows plugins as shareable, namespaced bundles for skills, agents, hooks, MCP servers, language servers, monitors, and settings. The association with the large-codebase guide is organisational: move conventions into centrally owned, versioned packages when per-directory copies begin to drift.
Anthropic: Automate actions with hooks
Catalogues lifecycle and tool events that can trigger commands, prompts, agents, or HTTP calls. The examples cover notification, formatting, protected files, context restoration, audits, environment reloads, and permissions. The key synthesis with the cost and skills sources is to use hooks for automatic, narrow, deterministic transformations rather than putting every mechanic into the prompt.
OpenAI: Using skills to accelerate OSS maintenance
Provides a repository case study combining short AGENTS.md routing, local
skills, scripts, and GitHub Actions. Its skills cover verification, docs sync,
examples, implementation strategy, release review, changesets, integration
tests, coverage, and PR handoff. The transferable pattern is a narrow contract,
clear trigger, concrete output, and shared local/CI logic—not the exact skill
list or the reported throughput correlation.
OpenAI: Harness engineering
Argues that the repository should be the agent-accessible system of record and that root instructions should be a table of contents. It broadens “context” beyond text by making UI, logs, metrics, architecture, and product knowledge legible to agents. It also warns that high throughput needs mechanical architecture rules and continual cleanup. The reported project is an experimental case study, so its organisational model should be adapted rather than copied wholesale.
Its concrete implementation adds the missing operational detail: per-worktree application and telemetry, browser-driven before/after evidence, a structured documentation tree, mechanically enforced dependency layers, and recurring quality cleanup. Its minimal merge gates are explicitly contextual and do not generalise with the rest of the guidance.
OpenAI: Shell + Skills + Compaction
Presents three complementary primitives: reusable procedures, real execution, and continuity across long runs. It adds useful routing advice—positive and negative boundaries, examples loaded only on demand, explicit invocation when determinism matters—and a security warning about combining powerful skills with open networking. Its hosted-container details are product-specific; the general principles apply to local runtimes too.
OpenAI: Unlocking the Codex harness
Describes a long-lived runtime exposed through a bidirectional, streaming protocol. Threads, turns, and items let clients render incremental work, artifacts, diffs, and approval requests. Server-held state permits reconnects and continued execution when a browser disappears. This complements the agent loop article by showing how to turn internal loop events into a stable client integration boundary.
OpenAI: Unrolling the Codex agent loop
Explains how a turn repeatedly alternates model inference and tool execution, with prior messages, calls, results, instructions, permissions, environment, and tool schemas becoming subsequent input. It highlights prompt-cache sensitivity, independent tool guardrails, and compaction. This is the mechanical foundation beneath the higher-level recommendations about context cost, durable artifacts, and stateful runtimes.
Tensions to preserve
- Automatic routing versus guarantees: skill discovery is valuable, but a mandatory workflow should be invoked explicitly or enforced by tooling.
- Local context versus central governance: local skills stay relevant to code; centrally distributed plugins reduce duplication. Use both at their appropriate scope.
- Rich context versus cost: more observability helps only when it is queryable and focused. Dumping every log or document into the prompt reverses the benefit.
- Portability versus capability: common protocols simplify multi-provider integration but can flatten provider-specific lifecycle, approval, or diff semantics.
- Autonomy versus containment: execution makes workflows useful; filesystem, network, secrets, and external tools therefore require independent controls.