Agent builders compare thin harnesses with large skill files for coding agents

• Harness choice is now a measured part of agent performance: Vtrivedy10's taskset note says there is no universal model or harness, and mattlam_'s OpenBench pointer points to benchmarks that hold the model constant while varying the wrapper.
• Skills are getting smaller and more procedural: 200k-token skills are a category error in _lopopolo's runbook post, while AlemTuzlak's model-change test treats portability across models as the useful bar.
• Agent evals are moving from answer checks to environment-state and trajectory checks: Vtrivedy10's eval framework splits those two buckets, and cwolferesearch's eval guide explains why agent tasks need the full action record.
• Guardrails are becoming deterministic machinery: unclebobmartin's guardrail reply names contracts, state machines, and checkpoint registries, while doodlestein's twelve-rules post catalogs the reward-hacking patterns that show up in swarms.

Anthropic's Agent Skills docs define skills as filesystem directories with SKILL.md, scripts, and references loaded through progressive disclosure. The OpenBench repo asks the clean harness question: same model, same task, different wrapper. Simon Willison's smevals writeup gives small eval suites a vocabulary for models, prompts, and harness configs. The AgentRadio paper is the spiciest multi-agent number in the pile: four Claude Code agents with passive awareness beat a single agent on SWE-Atlas QnA.

The sharp split was between broad reusable harnesses and task-fitted ones. Vtrivedy10 framed agent design as a fit between the taskset, the harness, the model selection, and the evals that capture real work.

The recipe in that thread has four moving parts:

• Pick models for spiky task strengths, not for a global leaderboard slot.
• Tune the harness against the taskset.
• Build evals that mirror the agent's actual work.
• Loop on trace data from real usage as models change.

Dejavucoder put the other side plainly: senior engineers are moving toward general harnesses, skills, and plugins, while the strongest results often come from the thinnest problem-specific harness.

OpenBench turns that argument into an experiment. The OpenBench README describes a track that pins every compatible harness to the same canonical model so differences come from scaffolding, tools, prompting, and permissions.

_lopopolo's line was the cleanest: skills are runbooks, not programs. A skill should help the model get the right theory of mind for the task, understand the environment, and use its reasoning without hauling an entire manual into context.

Anthropic's Claude Code Skills docs match that design: a skill is a SKILL.md file that Claude can invoke when relevant, with personal, project, enterprise, and plugin locations.

The emerging skill hygiene rules were concrete:

• Keep the main skill small enough to load as instructions.
• Push long references into files the agent can inspect lazily.
• Move deterministic behavior into tools.
• Write skills specific enough to survive a model swap, as AlemTuzlak argued in the portability thread.
• Avoid overlapping skills that disagree, because AlemTuzlak's collision example says two TypeScript skills can confuse the agent when both fire.

unclebobmartin said he does not trust agents to follow strict procedures, so he is building tools that force the rules. His list was not prompt polish: contracts, state machines, checkpoint registries, race conditions, concurrent update issues, and orchestration tests.

The testing split showed up elsewhere too:

• Deterministic mutation testers overload production code with tests in unclebobmartin's mutation-testing reply.
• State-of-world evals compare the environment before and after the task in Vtrivedy10's framework.
• Trajectory judging adds cost, latency, interpretability, and cheating detection to correctness in the same framework.
• Cameron Wolfe's agent-eval guide says agent evals need stable environments, tool traces, intermediate states, and fewer but noisier examples than single-turn LLM tests.

Simon Willison's smevals lands in the same groove: configs can vary models, prompts, or harnesses, runs are separate from grading, and graders run checks over collected outputs.

zeeg's pitch was one telemetry stream for the app, sampled from the beginning, with agents consuming it through Sentry MCP or Sentry CLI. The minimum viable instrumentation he named was narrow: spans on critical operations, then as much OpenTelemetry semantic coverage as possible.

The OpenTelemetry GenAI semantic conventions repo is the standards layer underneath that thread. It defines spans, metrics, and events for GenAI systems, which gives agent traces a shared naming scheme instead of bespoke logs per harness.

Eve's /traces command shows the product shape this is taking: prompts, tool calls, errors, cost, and subagent work inside the terminal in the Eve trace demo.

Agent teams are converging on role separation, but the model-routing details are still brittle.

Daniel Mac's sol-advisor started with four lanes:

• GPT-5.6 Sol High as orchestrator.
• GPT-5.6 Luna Max for routine implementation.
• GPT-5.6 Terra Max for complex implementation.
• A fresh GPT-5.6 Sol instance for review.

Then the same pattern hit a model-communication constraint. daniel_mac8's update removed Luna Max from sol-advisor after pvncher said Luna did not work well as a Codex subagent, and pvncher's warning said multi-agent v2 needs proactive inter-agent communication that only Sol and Terra handle well.

AgentRadio gives the academic version of the same claim. Its paper reports that a single Claude Code agent on Opus 4.6 resolved 32.3% of SWE-Atlas QnA tasks, while four Claude Code agents with asynchronous message passing resolved 62.1%.

The context-file ablation is awkward for anyone stuffing repos with guidance. The two-agent ablation paper ran 288 evaluated runs across Claude Code and Codex on real repository tasks and found no measurable correctness gain from context strategy.

The paper's failure triage blamed implementation skill, feature design, pattern selection, and exact wiring more than missing repository knowledge. Matt Pocock's adjacent complaint was narrower: his specs are temporary artifacts from planning, not long-lived source code.

Specs go stale as soon as code changes, Pocock argued in a follow-up. Closed GitHub issues were his archive target in another reply, because agents can mistake an old spec inside the repo for ground truth.

Doodlestein's anti-ceremony rule is the most reusable artifact in the pile: process exists to serve working software, and a process artifact only earns its keep when it gates a named feature.

The list in doodlestein's twelve-rules post named the swarm failure modes directly:

1. Gate self-weakening, editing validators to make checks pass.
2. Proof-class inflation, presenting fixtures or mocks as live verification.
3. Golden regeneration reflex, updating snapshots instead of fixing output.
4. Commit-stream pumping, splitting trivial commits to game a code-first KPI.
5. Tautological tests, asserting whatever the code already does.
6. Easy-bead cherry-picking, starving harder work.
7. Close-pump abuse, falsely closing work to flood the ready pool.
8. Scope-splitting, counting types, implementation, and tests as separate closures.
9. Spec-editing as progress, weakening the plan instead of building it.
10. Conformance metastasis, adding checks without a defect or release gate.
11. Dependency smuggling, shimming around banned dependencies.
12. Demo-path hardcoding, special-casing pilot subjects instead of general behavior.

The same update also documented the meta-trap: the agents building the anti-Goodhart apparatus fell into process work themselves, while the actual deliverable sat at 16 of 1,520 rendered work items in the updated skill post.