cd /news/ai-tools/software-development-after-one-year-… · home › topics › ai-tools › article
[ARTICLE · art-173681] src=explainx.ai ↗ pub= topic=ai-tools verified=true sentiment=· neutral

Software Development After One Year With AI: A CTO's Field Guide

Twnstr CTO Robert Stark published a November 12, 2026 essay arguing that AI-heavy development means code is "grown, not created," that nobody reads repositories line by line anymore, and that "slop compounds" unless teams schedule cleanup passes the way they schedule features. Stark's field guide, which reached Hacker News on November 21, 2026, prescribes a human-authored constitution document covering purpose, principles, stack and loop rules, plus metaplans that keep goals outside the context window so fresh agent sessions and third-party agents share the same ground truth. The essay targets teams using Claude Code, Cursor or Codex daily and addresses the review bottleneck described in Harvard's code-review study, where output rises faster than review bandwidth.

recommendation

Write a human-authored constitution covering purpose, principles, stack and loop rules before agents write code, and schedule regular cleanup passes so accumulated slop doesn't degrade the next agent run.

more in playbook: Working with AI coding agents
by read8 min views2 publishedNov 21, 2026
Software Development After One Year With AI: A CTO's Field Guide
Image: Explainx (auto-discovered)

Robert Stark, CTO at Twnstr, says a year of AI-heavy development rewired how he ships software. His November 12, 2026 essay landed on Hacker News on November 21 with practitioners asking how to adapt. Stark's thesis is blunt: code is grown, not created, nobody reads repos line by line anymore, and slop compounds unless you schedule cleanup the way you schedule features.

This is not a tool review. It is an operating manual for teams already using Claude Code, Cursor, or Codex daily—and hitting the same walls Harvard's code-review bottleneck study (see also Jellyfish's write-up of the Harvard study) describes when output rises faster than review bandwidth.

TL;DR: Stark's rules in one table #

Idea Stark's practice Why it matters
Constitution doc Why, principles, stack, loop rules before agents write Aligns sessions that lack chat history
Metaplans Tree of goals; execute leaves; keep parents for weeks Stops repeated wrong assumptions
Domains and layers Breadth domains, depth layers, stateless pkg sharing Narrows agent search, cuts duplicate helpers
Rewrite cadence Explore alternate designs often; ship migration rarely Cheap pivots without sunk-cost drift
Slop cleanup Scheduled passes for comments, locks, temp tests Bad structure makes the next agent pass worse
Weights win Stop fighting billion-example habits; automate cleanup instead Saves prompt fatigue

Code is grown: what changes in daily craft #

Stark opens with the largest mental shift. Pre-agent workflows assumed a human could hold the whole system in memory for weeks while refining one vision. Now collaborators arrive the moment a git repo exists, and the codebase outpaces individual comprehension in days.

His response is horticulture, not authorship: plant constraints, inspect growth, prune. That matches how loop engineering treats agent runs as repeatable cultivation rather than one-shot miracles.

For founders, the payoff is faster throwaway prototypes. Stark runs hypothetical migrations—"what if we used Bazel?" or "split search into its own database?"—every couple of weeks even when he almost never executes them. The plans still reveal hidden coupling, which is data you used to earn only after months of manual archaeology. Modular coding prototype on a drafting triangle, illustrating AI-grown codebases

Constitution documents beat prompt dumps #

Stark's constitution is the artifact explainx.ai recommends in every agent rollout, echoing DESIGN.md-style specs and No Slop Manifesto discipline:

  • Purpose — why the repo exists.
  • Principles — non-negotiable design taste.
  • Stack — approved languages and services.
  • Loop rules — how an agent session should start and end.

He notes models got better at honoring why statements, not only what commands. The constitution becomes the README so every fresh session and every third-party agent sees the same ground truth. That directly answers searchers asking how to review code with AI: reviewers compare diffs to the constitution, not to whatever the model guessed this afternoon.

If you run workshops, pair this with a single promoted skills file—see /skills for patterns—but keep the constitution human-authored. Agents should not invent your ethics or compliance rules.

Metaplans: memory outside the context window #

Stark's metaplans are his answer to missing context, which he calls the root of most model mistakes. He builds a hierarchy of markdown files:

  1. Top-level goals.
  2. Mid-level decisions and trade-offs.
  3. Leaf tasks with concrete file touch lists.

Agents execute leaves. Parents remain on disk for weeks, feeding the next planning round. That is filesystem-backed memory cheaper than giant chat logs and more auditable than mystery vector stores.

The pattern rhymes with Microsoft's proof-driven development kit: keep intent artifacts durable while implementation churns. It also reduces the verification tax teams report when they must re-derive decisions every sprint.

Stark enforces breadth domains (users, tokens, trust providers) and depth layers (persistence, handlers, daemons). Shared code lives in stateless pkg directories at the lowest possible level.

Why bother? Agents over-search when repos are flat. Once they read an irrelevant package, they convince themselves it matters and ship off-target edits. Narrow structure lets him command "update the user persistence layer" without pasting paths—similar to how Claude Code subagents benefit from scoped working sets.

He runs linters for architectural rules, not just syntax. That is how you scale token-efficient sessions: smaller search graphs, fewer junk tokens.

Iteration through rewrite, not endless tweak #

Stark celebrates rewrite-friendly culture. AI makes spinning a new architecture cheap; sunk-cost attachment becomes the bigger risk. He still ships only a handful of migrations per year, but the exploration tax is low.

Contrast that with legacy systems stuck in local minima—exactly what Proton's "programming is dead" debate fears when teams stop understanding their stacks. Stark's compromise: agents propose, humans select, constitution bounds.

Stark also runs counterfactual architecture reviews on a two-week cadence. The habit looks wasteful until an agent plan exposes that two services share a hidden database lock or that a feature flag no longer gates anything. Those findings used to require senior engineers with years of tenure; now a careful prompt plus repo access surfaces them in an afternoon—if your tree is searchable.

Slop compounding and scheduled cleanup #

Stark's slop compounding warning is the essay's hardest-hitting section for production teams. Symptoms he lists:

  • Redundant input guards models add reflexively.
  • Database locks agents sprinkle "just in case."
  • In-package interfaces nothing else imports.
  • Temporary tests agents forget to delete—he names Astra as a repeat offender in his stack.

His fix is explicit cleanup loops in the development cadence: comment reduction, decoupling passes, asking the model which mutexes are removable. That aligns with libreboot dropping anti-AI policy to fight slop and the wider hungry butler sycophancy incentives research on models agreeing too easily.

Teams measuring velocity only by lines added will miss this until incident response slows down. Pair Stark's cleanup with human-in-the-loop review metrics.

YAGNI, DRY, and prompt-level discipline #

Stark retargets classic principles:

  • YAGNI applies toprompts —ask for one thing at a time.
  • DRY applies tostructure —duplicate functions across folders confuse search.

That is the antidote to vibe coding without guardrails, covered in /blog/what-is-vibe-coding-explained-2026 and how to stop vibe coding. Structure is how you keep vibe experiments from metastasizing.

"You can't fight the weights" #

Stark closes with humility: if the training corpus contains a billion historical comments, your prompt will not erase them. Keep standards in the constitution, run cleanup, choose battles.

That is good counsel for leaders banning practices outright. Policy plus automation beats policy alone, and that holds even for mundane comment spam.

Reading repos through agents, not eyeballs #

Stark's second big claim is that no one reads full codebases directly anymore—even beautiful ones. Reviewers and tech leads ask models to summarize, trace call paths, and diff behavior against the constitution. That shifts hiring signals: fluency with agent interrogation matters as much as raw syntax speed.

The risk is false confidence. Models paraphrase incorrectly. Stark mitigates by keeping metaplan parents that record why a module exists, so a reviewer can spot when an agent invents purpose. Pair that with token-efficient Claude sessions so investigations do not burn entire context windows on unrelated folders.

For security-sensitive code, treat agent summaries as untrusted until a human spot-checks critical paths—same discipline as HAProxy maintainer reports on AI bug noise.

Prompt-level YAGNI in practice #

Stark's YAGNI-for-prompts rule sounds simple but changes session outcomes:

Bad prompt shape Stark-style replacement
"Build auth, billing, and admin UI" One leaf: "Add password reset endpoint per constitution"
"Refactor everything to microservices" Metaplan parent explores; single leaf migrates one boundary
"Make it faster" Measurable leaf: "Remove redundant row lock in userdao per metrics"

Smaller asks reduce partial completion, where agents touch six files and finish none. They also make git review tractable for humans still on the hook legally.

What Hacker News added #

The HN thread was still thin on November 21—submitter BobbyJo posted the link and a short note that the piece shares how they adapt day-to-day engineering work; no substantive practitioner debate yet. Watch for hands-on reports on constitution tooling and whether metaplans beat ticket systems. When substantive comments appear, treat them as anecdotes, not verified benchmarks.

How to adopt this Monday #

  1. Write a one-page constitution before your next agent sprint.
  2. Create a metaplan directory ; never start a session without linking the relevant parent file.
  3. Book a weekly 30-minute slop pass with metrics: lines removed, duplicate helpers merged.
  4. Add one architectural lint agents cannot bypass.
  5. Log rewrite experiments even when you do not ship them—Stark's learning came from plans, not merges.

For structured training, see Claude for work workshops and the top Claude live workshops list.

When Stark's playbook breaks down #

Stark writes from a CTO with repo authority vantage. It weakens when:

  • Constitutions are missing and multiple vendors' agents touch the same monorepo.
  • Compliance requires human sign-off on every line in regulated modules—metaplans help but do not replace audit trails.
  • Models shift underneath you mid-sprint; cleanup loops must includeregression harnesses , not only comment deletion.

In those cases, borrow his structure ideas but add formal verification pilots on payment or identity code paths.

Stark's essay and tooling references are accurate as of November 21, 2026.

── more in #ai-tools 4 stories · sorted by recency
── more on @robert stark 3 stories trending now
sponsored brought to you by zahid.host 4,200+ EU-deployed projects
reading about agents? ship yours in a single git push.

Run your AI side-project on zahid.host

EU-based hosting, git-push deploys, automatic HTTPS, no cold starts. Free tier with a custom domain — perfect for shipping the agent you just read about.

$git push zahid main
→ Live at https://your-agent.zahid.host ✓
Get free account → Pricing
from €0/mo · no card required
LIVE [news/software-development…] indexed:0 read:8min 2026-11-21 · —