[Agentic Coding] Header Project

COMPLETED June 09, 2026
Summary

Briefing: [Agentic Coding] Header Project

Purpose: Developer at a 1-3 person startup, Python/FastAPI/Expo stack, heavy Claude Code investment, seeking tactics for frontend/mobile agent gap, Python-side friction, cross-service debugging, parallel/scheduled agents, harness compounding, and deterministic verification.

Key Insights

  • The harness outperforms the model—and your ~60 memory entries may already be hurting you. A 22% performance gap between harnesses has been empirically documented (distinct from model quality), and two independent data points triangulate a counter-intuitive failure mode: a skill added to a WorkOS agent reduced correct-answer rate from 97% to 77% on the exact task it was designed for, and deleting 95% of generated skills cut run time from 68 minutes to 6. The KL-divergence principle explains why: memory files should store only what the model doesn't already know—project-specific invariants, not generic patterns it encodes at training. For your ~60 .claude/memory/ entries: run a blunt audit asking "would Claude get this wrong without this entry?" and delete anything that fails; the remainder is likely 5-10 entries that genuinely encode pitfalls specific to pgbouncer quirks, Alembic under parallel-agent work, or your FeedForge auth contract.
  • How I deleted 95% of my agent skills and got better results
  • ⚡️Making DeepSeek v4 outperform Opus 4.7 with Taste
  • Agentic Evaluations at Scale, For Everybody

  • Is Grep All You Need? How Agent Harnesses Reshape Agentic Search

  • Your Expo/RN knowledge gap now has three directly installable patches. This Week in React #283 surfaces three concrete tools: Callstack Apex (a domain-specific Gemma 4 model fine-tuned for React Native coding tasks, currently in private beta), Margelo's open-source RN agent skills targeting exactly the friction points you named (Nitro Modules, VisionCamera, MMKV), and Expo SDK 56's worklet/useNativeState() primitives for flicker-free <TextInput> masking that explain why Claude Code drifts on safe-area handling. These aren't tutorials—they're installable components that close the gap by giving the agent ground truth about the current RN architecture rather than its training-data approximation. Action: install Margelo's RN skills into .claude/skills/ immediately; they directly target the VisionCamera/MMKV patterns that generate the most drift, and the Expo SDK 56 primitives entry should become a dedicated skill file so Claude stops reaching for the old architecture.

  • This Week In React #283

  • The maker/checker split is the single most production-validated architectural upgrade available to you right now. Dropbox Nova (CI-gated validation loop with a 5-attempt cap), Lorikeet (Concierge + Coach + diagnosis agent on traces), Cloudflare's adversarial review agent (different prompt, no ability to generate its own findings), and the WorkOS five-agent state machine all independently converge on the same structure: the agent that writes code must not be the agent that verifies it because they share the same blind spots. The cryptographic test-proof pattern from Nick Nisi—SHA-256 hashing test output and requiring the verifying agent to produce that hash—closes the most common failure mode where an agent lies about test passage. For your existing /confidence and /compound pre-commit hooks: add a hard requirement that the primary agent cannot report success without a separate verification step that produces a cryptographic or structural proof; your hooks are already the right architecture, they just need the verification to be unforgeable rather than self-reported.

  • Introducing Nova, our internal platform for coding agents
  • How I deleted 95% of my agent skills and got better results
  • Building Lorikeet: How AI Humility and a Dual-Agent Architecture Are Redefining Customer Support

  • Loop Engineering

  • Your weekly scheduled agents have a concrete blueprint that doesn't require vendor lock-in. The most directly implementable architecture in this corpus is a four-component system: an identity markdown file, a macOS LaunchAgents scheduler (or any cron equivalent), a tasks/ folder of markdown files with frontmatter, and a scripts/ utilities folder—all stored in an Obsidian-neutral location rather than inside .claude/ so they work with Claude Code, Codex, or any future CLI without migration. The key additions from Gant Laborde's "Night Shift" workflow: a feedback file the agent writes back to you (flagging bad specs or corrections it had to make), self-healing documentation updated when the process corrects itself, and a state-justification gate requiring the agent to explain any new state it introduces. Dropbox Nova's production-validated upper bound is a 5-attempt cap before requiring human intervention. For your weekly routines: add a feedback.md file that your agent writes to at the end of each run—this single addition converts your existing schedule from a fire-and-forget loop into a compounding improvement system that tells you when your specs are the problem.

  • My Team of Agents: How I Get Claude to Do Tasks While I'm Away from the Computer
  • RNR 364 - AI Triforce with Gant Laborde

  • Introducing Nova, our internal platform for coding agents

  • Nightly log-driven skill distillation is the qualitative leap beyond your current static memory entries. Skill distillation—where a frontier model (Opus/GPT-5.1) authors and grades atomic SKILL.md files, iterating until accuracy converges, while a smaller model executes them—turns your weekly scheduled agents into a self-improving system. The architecture has three layers: a local markdown knowledge base (~80 workflow files searched before answering any procedural question), atomic skills authored and evaluated by the frontier model, and a nightly log-processing run that identifies what new skills should be generated based on failure patterns. Critically, "the student becomes whichever model happens to be cheapest this quarter"—the skill library is the durable asset, not the model choice. This directly solves your model-churn problem: invest 2-4 hours prototyping the nightly log-to-skill generation loop using your existing JSONL session transcripts as input; even a crude version converts accumulated failures into forward guards rather than leaving them as retrospective notes.

  • Skill Distillation
  • How Anthropic Engineers ACTUALLY Prompt Claude Code (Full Guide)
  • Inside YC's AI Playbook

Emerging Patterns

1. Grep outperforms vector retrieval in Claude Code's tool-calling paradigm, which validates your structured .claude/ investment over RAG. An arXiv empirical study on agent harnesses confirms that grep-based retrieval generally yields higher accuracy than vector retrieval in Claude Code's specific tool-calling paradigm—harness and tool-calling style dominate retrieval method. The study also identifies that agent performance degrades when searches must cope with "distracting material," which is precisely what bloated .claude/memory/ files produce. The implication is counterintuitive for teams considering semantic search: for Claude Code specifically, well-organized markdown files with clear grep-friendly structure outperform embeddings-based retrieval. This validates your existing structured .claude/ investment, but with a corollary: the files need to be pruned aggressively because noise in a grep-friendly corpus degrades performance faster than noise in a vector store. - Is Grep All You Need? How Agent Harnesses Reshape Agentic Search - RAG is dead, right?? — Kuba Rogut, Turbopuffer - Benchmarking semantic code retrieval on Claude Code

2. Tool-call schema failures are deterministic bugs, not stochastic model failures—and they're fixable with repair logic. Multiple sources converge on a pattern that often looks like "agent friction" but is actually a deterministic contract mismatch: models (especially open models and Gemini's OpenAI-compat layer) emit incorrect JSON schemas—null where a value is expected, a string where an array is required. The repair pattern is to intercept these failures before returning them to the agent, programmatically fix the format, and provide a hint back—this is not prompt engineering, it's a shim in the adapter layer. Your Gemini OpenAI-compat null-content issue is the canonical example. Cloudflare's production pattern adds JSONL streaming robustness (always-valid files even mid-stream) and retry logic on finish_reason=length. Treat your multi-LLM adapter's error-handling layer as a first-class product feature: implement repair logic for the 3-4 known schema failure patterns from Gemini and Groq before they generate confusing agent behavior that looks like reasoning failures. - ⚡️Making DeepSeek v4 outperform Opus 4.7 with Taste - I Ranked Cloudflare's Software Factory and Wow… S TIER TOKENOMICS

3. AGENTS.md/CLAUDE.md files rot faster than code and the rot is silent—the user's existing pattern of 60+ entries is the highest-risk part of their harness. Three independent sources document the same failure mode: CLAUDE.md/AGENTS.md files created during one model generation become actively harmful when used with the next, because they encode behavior-steering that was model-specific (e.g., "think step by step" worked for one model, confuses another), contain outdated architectural descriptions, and consume context budget with information the model already encodes. Unlike code technical debt that manifests as errors, prompt decay is "silent"—the agent produces slightly worse output with no clear signal why. The "intent ledger" framing (write only what would be expensive to reconstruct, the "why behind choices that would be expensive to get wrong") is the correct filter, and the MECE/DRY check-resolvable meta-skill is the ongoing maintenance mechanism. Schedule a quarterly CLAUDE.md audit as a recurring task; treat any entry older than 2 major Claude Code releases as suspect; the T3 example (repo entirely rewritten, CLAUDE.md unchanged for 2 months) is exactly what your 60-entry memory file risks becoming if it isn't on a maintenance schedule. - The Intent Debt - More Prompts = Worse Code? - Inside YC's AI Playbook

Dissenting Views

Should you heavily customize your harness, or stay stock? The prevailing view across Anthropic engineering practice and production teams (Lorikeet, Dropbox Nova, WorkOS, Shopify) is unambiguous: heavy harness investment compounds. Anthropic engineers themselves run iterative skill refinement on every imperfect session; the skill that performed in production today is "the worst it will ever be." But Sean Goedecke's "More Prompts = Worse Code?" makes a pointed counter-argument worth taking seriously: prompt adjustments are model-specific and decay silently, and for most developers the time investment in customization rarely pays off given model churn—he advocates using third-party tools as close to stock as possible and letting the vendor's engineers do the tuning. This is a methodological disagreement, not a factual one. The resolution for your situation: Goedecke's argument applies to generic customizations (behavior-steering prompts, "think step by step" instructions, tone directives); it does not apply to project-specific invariants that encode your actual stack's pitfalls—asyncpg/pgbouncer quirks, Expo Router conventions, FeedForge auth contracts. Those are exactly what base models cannot know and what your harness should encode. The pruning question is not "should I have a harness?" but "is each entry in my harness encoding something the model genuinely cannot infer?" - More Prompts = Worse Code? - How Anthropic Engineers ACTUALLY Prompt Claude Code (Full Guide) - RNR 364 - AI Triforce with Gant Laborde

Read & Act

What to Read

  • Loop Engineering — The single most architecturally complete reference for your parallel/scheduled agent requirements. Covers git worktree mechanics for sandboxing, SKILL.md as "intent written down on the outside," the maker/checker split with the specific framing that "the model that wrote the code is way too nice grading its own homework," and durable state via repo ("the agent forgets, the repo doesn't"). Integrates across all six of your pain points in a single methodology article.

  • How Anthropic Engineers ACTUALLY Prompt Claude Code (Full Guide) — Contains the most directly applicable operational guidance from inside Anthropic: the three-layer skill architecture (description/instructions/tools) with specific YAML flags (disable_model_invocation, user_invocable), the principle that "the tools layer is where the leverage lives" with bare-bones function definitions, HTML over markdown for output format, and the iterative skill improvement loop. The structural specifics matter and can't be adequately summarized—this is the source to verify your current 16-skill architecture against.

  • Skill Distillation — The most novel harness architecture pattern in this corpus for your weekly scheduled agents. Introduces frontier-model-as-teacher / small-model-as-executor with nightly log-driven skill generation. The "student becomes whichever model happens to be cheapest this quarter" framing directly solves the model-churn problem that makes heavy harness investment feel risky. Short enough to read in 10 minutes, concrete enough to prototype immediately using your existing JSONL session transcripts.

  • My Team of Agents: How I Get Claude to Do Tasks While I'm Away from the Computer — The only entry in this corpus that implements the exact weekly scheduled remote agent pattern you described, with concrete macOS tooling (LaunchAgents), a four-component architecture that works across Claude Code/Codex/any CLI, and Obsidian-neutral storage that avoids vendor lock-in. The retrospective agent generating weekly tips is a direct template for your existing weekly routine.

  • How I deleted 95% of my agent skills and got better results — The quantitative findings (553 lines vs 10K lines → 6 min vs 68 min runs; 97% vs 77% correct with/without a specific skill) challenge the assumption that more memory entries compound positively. The cryptographic test-proof pattern, five-agent state machine with enforced gates, and retrospective agent on JSONL transcripts are all directly implementable and address your verification and memory-management pain points simultaneously.

What to Do

1. Audit your .claude/memory/ entries this week using the KL-divergence filter. Print your 60 entries and apply a single question to each: "Would Claude get this wrong without this entry on a blank-context run?" If the answer is "probably not"—if it's general Python best practice, common FastAPI patterns, or generic async advice—delete it. Entries that survive are project-specific invariants: your pgbouncer pool mode requirements, the specific way FeedForge expects auth headers, Expo Router conventions that differ from the Next.js patterns Claude was trained on. Target getting below 20 entries. Then run a session with and without your top 5 most-loaded entries to measure whether they're helping or hurting—the WorkOS data suggests at least one of them may be actively degrading performance.

2. Create a Margelo RN skills install and a dedicated Expo SDK 56 skill file before your next frontend sprint. The Margelo skills (https://thisweekinreact.com/newsletter/283) directly target the VisionCamera/MMKV/Nitro Modules friction points. For Expo SDK 56's new architecture, write a single skill file that encodes the worklet/useNativeState() pattern for TextInput masking and the safe-area-inset CSS approach (env(safe-area-inset-*))—these are exactly the kind of project-specific, recent-architecture details that Claude's training data doesn't reliably contain and that your .claude/skills/ is the right place to capture.

3. Add a feedback.md write-back to your weekly scheduled agent loop. This is the single highest-leverage addition to your existing weekly routine. Configure your agent to write to this file at the end of each run: any prompt or spec that was unclear, any place it had to correct a wrong assumption you gave it, any correction it made that you would want to carry forward as a memory entry. This converts your weekly run from a static execution into a feedback loop that tells you which specs need tightening—and over time, the patterns in feedback.md become the input to a nightly skill-generation pass.

Source Articles