explainx.ai350K+ learn from us
TrendingAI News TodayExplainx for Business
Pricing
explainx.ai

Upskill in AI — 16 free pathways, live workshops & bootcamps, and 50+ courses from practitioners. Plus the skills, tools, and MCP servers to practice on.

follow us

follow on google

Add explainx.ai as a preferred source

corporate training

support@explainx.ai

get started

Find your pathTake Free Evaluation

community

Join the community

learn

mind: share how you thinkpathways — start freeworkshopsbootcampscoursescompare Explainxcertificationsmock testsexplainx universitycorporate traininglearn skills & mcp

discover

skillsmcp serversexplainx mcpestacktoolsmdx readeragentsllmsdesignsdictionarypeopleagi trackerfelony benchranks

company

aboutvisionmissionteaminstructorsteach on explainxpartnershipscommunityhackathonscareers

content

daily AI newsstate of AI — live resultsblogreleasespromptsgeneratorsresource libraryfor LLMsexplainx.ai kids

solutions

all solutionsdeveloper upskillingmarketing upskillingproduct manager upskillingleadership upskilling

newsletter · weekly

Get AI news, tools, and insights in your inbox.

supportcontactprivacytermsdata rightshow we create contentsubmission guidelines

© 2026 AISOLO Technologies Pvt Ltd

explainx.ai

On this page

  • TL;DR: Stark's rules in one table
  • Code is grown: what changes in daily craft
  • Constitution documents beat prompt dumps
  • Metaplans: memory outside the context window
  • Domains, layers, and linters agents can search
  • Iteration through rewrite, not endless tweak
  • Slop compounding and scheduled cleanup
  • YAGNI, DRY, and prompt-level discipline
  • "You can't fight the weights"
  • Reading repos through agents, not eyeballs
  • Prompt-level YAGNI in practice
  • What Hacker News added
  • How to adopt this Monday
  • When Stark's playbook breaks down
  • Related on explainx.ai
← Back to blog

explainx / blog

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

AI Coding, Agent Workflows, Claude Code, Software Craft, Vibe Coding

Part of AI Coding Tools

Twnstr CTO Robert Stark wrote how AI changed his craft: constitution docs, metaplans, domain layers, and slop cleanup. What builders can copy from November 2026.

Nov 21, 2026·8 min read·Yash Thakker
add explainx.ai
go deep
Software Development After One Year With AI: A CTO's Field Guide

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.

Daily briefFrom Yash · 350K+ students taught

Catch up on AI

One AI story explained in plain English, plus one thing to try. Every day, free. Unsubscribe anytime.

TL;DR: Stark's rules in one table

table · 3 cols
IdeaStark's practiceWhy it matters
Constitution docWhy, principles, stack, loop rules before agents writeAligns sessions that lack chat history
MetaplansTree of goals; execute leaves; keep parents for weeksStops repeated wrong assumptions
Domains and layersBreadth domains, depth layers, stateless pkg sharingNarrows agent search, cuts duplicate helpers
Rewrite cadenceExplore alternate designs often; ship migration rarelyCheap pivots without sunk-cost drift
Slop cleanupScheduled passes for comments, locks, temp testsBad structure makes the next agent pass worse
Weights winStop fighting billion-example habits; automate cleanup insteadSaves 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 codebasesModular 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.

Domains, layers, and linters agents can search

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 to prompts—ask for one thing at a time.
  • DRY applies to structure—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:

table · 2 cols
Bad prompt shapeStark-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 include regression harnesses, not only comment deletion.

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

Related on explainx.ai

  • Loop engineering with coding agents
  • Claude Code commands reference
  • Harvard on the code-review bottleneck
  • No Slop Manifesto takeaways
  • DESIGN.md templates for agents
  • What is vibe coding?
  • Claude Code token efficiency

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

Spotted something out of date? Let us know.
Daily briefFrom Yash · 350K+ students taught

Catch up on AI

One AI story explained in plain English, plus one thing to try. Every day, free. Unsubscribe anytime.

  • ✓ Free
  • ✓ One email a day, no spam
  • ✓ Unsubscribe anytime
Yash Thakker

Written by

Yash Thakker

Yash is an AI expert with over 300K learners. Join his workshops →

View Yash Thakker in People in AI →

Related posts

Aug 8, 2026

Compiss: A Toilet-Finder App Built Entirely with Claude Code

A viral r/ClaudeAI post shows Compiss — a free "emergency toilet radar" app with a literal compass UI, live on the App Store, Google Play, and Apple Watch — built end to end with Claude Code. explainx.ai breaks down what the OP actually shipped, the Android crash reports, and what it teaches solo builders shipping AI-coded apps to real app stores.

Aug 1, 2026

Software for One: Building Personal Apps with AI Coding Agents

Alex Waxman's essay on building four personal apps with Claude Code went to 105 points on Hacker News, reviving Robin Sloan's six-year-old "home-cooked software" idea. Here's the actual stack, the real cost, and the counterarguments worth taking seriously before you start your own.

Jul 17, 2026

AI Speeds Demos but Final Polish Takes Months — Kr$na's Dev Cycle Chart (July 2026)

Full-stack AI engineer Kr$na (@krishdotdev) posted the "new development cycle" July 16, 2026 — idea in minutes, working demo in hours, six months on the last 10%, then infinity in the graveyard. ThePrimeagen called it first principles. explainx.ai maps where AI actually helps and where human obsession still wins.