<?xml version="1.0" encoding="UTF-8"?><rss xmlns:dc="http://purl.org/dc/elements/1.1/" xmlns:content="http://purl.org/rss/1.0/modules/content/" xmlns:atom="http://www.w3.org/2005/Atom" version="2.0" xmlns:cc="http://cyber.law.harvard.edu/rss/creativeCommonsRssModule.html">
    <channel>
        <title><![CDATA[Stories by Frederick Pearce on Medium]]></title>
        <description><![CDATA[Stories by Frederick Pearce on Medium]]></description>
        <link>https://medium.com/@fpearce?source=rss-275a1bc818d2------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*T-OU4VYYzIyLjYOGEGFnyQ.jpeg</url>
            <title>Stories by Frederick Pearce on Medium</title>
            <link>https://medium.com/@fpearce?source=rss-275a1bc818d2------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 07:43:59 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@fpearce/feed" rel="self" type="application/rss+xml"/>
        <webMaster><![CDATA[yourfriends@medium.com]]></webMaster>
        <atom:link href="http://medium.superfeedr.com/" rel="hub"/>
        <item>
            <title><![CDATA[222 Plus Five States: The Compact’s Arithmetic, as of November 2026]]></title>
            <link>https://medium.com/@fpearce/222-plus-five-states-the-compacts-arithmetic-as-of-november-2026-3b1d21a429f5?source=rss-275a1bc818d2------2</link>
            <guid isPermaLink="false">https://medium.com/p/3b1d21a429f5</guid>
            <category><![CDATA[government]]></category>
            <category><![CDATA[american-politics]]></category>
            <category><![CDATA[elections]]></category>
            <category><![CDATA[2026-elections]]></category>
            <category><![CDATA[electoral-college]]></category>
            <dc:creator><![CDATA[Frederick Pearce]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 09:35:17 GMT</pubDate>
            <atom:updated>2026-11-16T09:43:51.005Z</atom:updated>
            <content:encoded><![CDATA[<h4>The compact’s arithmetic after the midterms, and why a new trifecta is not an enactment.</h4><p><em>Drafted with Claude Code, an AI coding tool, and edited by me. The ideas, claims, and any errors are mine.</em></p><figure><img alt="Title card for “222 Plus Five States: The Arithmetic,” from the series Counted, Not Assumed, with the subhead “New Democratic trifectas are not enactments. Results are unofficial until certified.” A panel headed “Electoral votes, 2024 allotments” lists the compact today at 222, then Pennsylvania 19, Michigan 15, Arizona 11, Wisconsin 10 and Nevada 6. A second panel, “Running total, 270 needed,” climbs from 222 today to 241, 256, 267, 277 and 283 as each state is added." src="https://cdn-images-1.medium.com/max/1024/0*InGFUB1SUuXhRNFv.png" /></figure><p>After the 2026 US midterms, it’s looking like six states will have new Democratic trifectas, with Democrats holding the governorship and both legislative chambers, according to the <a href="https://www.ncsl.org/state-legislatures-news/details/2026-state-legislative-elections-the-results-and-what-they-mean">National Conference of State Legislatures</a>’ unofficial count. Within days of the vote, outlets including <a href="https://www.usatoday.com/story/news/politics/elections/2026/11/06/democrats-elect-president-popular-vote-electoral-college/92631637007/">USA TODAY</a> and <a href="https://newrepublic.com/post/217594/democrats-seats-nationwide-end-electoral-college">The New Republic</a> were asking what those trifectas mean for how the US elects its president. Results are unofficial until certified, so this is a snapshot: the compact’s tally is as of November 9 and NCSL’s count as of November 6.</p><p>The reason is the National Popular Vote Interstate Compact (NPVIC). States that join agree to appoint their electors for whoever wins the national popular vote, but only once enough states have joined to hold 270 electoral votes, a majority of the Electoral College. Minnesota is one of the six trifecta states, but it’s already a member. The other five are not.</p><h3>The arithmetic</h3><p>As of November 9, 2026, the compact’s <a href="https://www.nationalpopularvote.com/state-status">status page</a> shows member jurisdictions holding 222 electoral votes, 48 short of 270. Using the 2024 allotments, the five non-member states hold:</p><ul><li>Pennsylvania: 19</li><li>Michigan: 15</li><li>Arizona: 11</li><li>Wisconsin: 10</li><li>Nevada: 6</li></ul><p>That’s 61. All five together would bring the compact to 283.</p><p>Pennsylvania and Michigan are each necessary: without Pennsylvania the total tops out at 264, without Michigan at 268. With both, any two of Arizona, Wisconsin and Nevada are enough, and any one alone is not.</p><p>Not every list includes Arizona. USA TODAY names Michigan, Minnesota, Nevada, Pennsylvania and Wisconsin. NCSL also counts Arizona, and so does The New Republic’s tally. Without Arizona, the four non-members reach 272. With it, 283.</p><h3>A trifecta is not an enactment</h3><p>Nevada and Michigan have both had Democratic trifectas before without joining. In 2019 Nevada’s legislature passed a compact bill, AB 186, and Governor Steve Sisolak <a href="https://archive.leg.state.nv.us/Session/80th2019/Reports/VetoMessages/AB186_80th_VetoMessage.pdf">vetoed it</a> on May 30. Michigan had one in 2023 and 2024, and its compact bill, HB 4156, <a href="https://www.nationalpopularvote.com/state-status">passed a House committee and went no further</a>.</p><h3>The legal question and the timeline</h3><p>Whether the Compact Clause requires Congress to consent to an interstate agreement like this one is still open. The <a href="https://crsreports.congress.gov/product/pdf/R/R43823">Congressional Research Service</a> has examined it and left it unresolved. The New Republic notes that the filibuster would matter if consent is required. USA TODAY reports that the compact could take effect as early as 2028.</p><h3>The allotments are a snapshot too</h3><p>The 2024 allotments are in force through the 2028 election. After the 2030 census, House seats, and with them electoral votes, are reapportioned, and the 270 math is redone on the new numbers. The record shows how fast a margin above 270 can shrink. The 19 current members and these five states together held 298 electoral votes under the 1970s allotments, and fewer under every reapportionment since: 294, 293, 290, 286, and 283 today. The 19 members alone have held between 222 and 230 under every apportionment since 1964.</p><p>The current allotments are public, free and need no key. <a href="https://api.us-presidential-election-center.org/v1/elections/2024?state=PA">GET /v1/elections/2024?state=PA</a> returns Pennsylvania&#39;s state_electoral_votes, 19. Swap in MI, AZ, WI or NV to check the rest.</p><p>I’m not arguing for or against the compact. The record behind this is the one I described in <a href="https://medium.com/@fpearce/222-votes-away-and-a-record-few-can-get-end-to-end-4a941e8fc5be">222 Votes Away, and a Record Few Can Get End to End</a>. It’s a follow-up in the series <a href="https://frederick-douglas-pearce.github.io/blog/category/us-presidential-vote/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=compact-arithmetic-after-midterms&amp;utm_content=series">Counted, Not Assumed</a>.</p><p><em>Drafted with Claude Code. The ideas, claims, and any errors are mine.</em></p><p>Thanks for reading! I’m writing this series one slice of history at a time, counted rather than assumed. Follow me here to get the next post.</p><p><a href="https://frederick-douglas-pearce.github.io/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=compact-arithmetic-after-midterms&amp;utm_content=footer">Site</a> · <a href="https://github.com/frederick-douglas-pearce">GitHub</a> · <a href="https://www.linkedin.com/in/frederick-douglas-pearce/">LinkedIn</a></p><p><em>Originally published at </em><a href="https://frederick-douglas-pearce.github.io/blog/2026/compact-arithmetic-after-midterms/"><em>https://frederick-douglas-pearce.github.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=3b1d21a429f5" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Developer in the Middle: A Value Check Before Agents Build]]></title>
            <link>https://medium.com/@fpearce/the-developer-in-the-middle-a-value-check-before-agents-build-2d56dd61a324?source=rss-275a1bc818d2------2</link>
            <guid isPermaLink="false">https://medium.com/p/2d56dd61a324</guid>
            <category><![CDATA[product-management]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-engineering]]></category>
            <dc:creator><![CDATA[Frederick Pearce]]></dc:creator>
            <pubDate>Mon, 16 Nov 2026 05:45:36 GMT</pubDate>
            <atom:updated>2026-11-16T05:45:36.022Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Why deciding what to build is still hard, and how my agent team checks it.</em></h4><p><em>Drafted with Claude Code, an AI coding tool, and edited by me. The ideas, claims, and any errors are mine.</em></p><figure><img alt="Title card for “The Developer in the Middle: A Value Check Before Agents Build”: agents made features easier to build, but not easier to decide which ones are worth it. Two panels compare one feature. At the merge gate, every technical check passed and nobody had asked who benefits. After a value review, no user was found, real configurations had zero instances of the pattern, and the feature was closed unmerged." src="https://cdn-images-1.medium.com/max/1024/0*y1jIsm24Ej7BjL36.png" /></figure><p>Coding agents produce more code than anyone can comfortably review, and most of the review goes to whether it works, not whether it’s needed. Agents have made features easier to build, but they haven’t made it easier to decide which ones are worth building. A feature nobody needs still costs something to build, and more to maintain or remove later.</p><p>I recently almost merged a feature that had passed every technical check in my setup: the architect’s review, the code review, and the check against its acceptance criteria. Then I reviewed the source it was based on and asked a question none of those checks asks: how would a user benefit from this? A value review by my pm agent found no user it would help, and a check against real configurations found nothing for it to catch. I closed the pull request unmerged.</p><p>This post is about that upstream check: who makes it, where it belongs in the process, and how to set work up so that coding agents have something worth building from.</p><p>My setup is the dev-loop, the Claude Code plugin I introduced in <a href="https://frederick-douglas-pearce.github.io/blog/2026/a-loop-to-remember/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=the-developer-in-the-middle&amp;utm_content=post-1">the first post in this series</a>. It runs my agent team through a backlog of GitHub issues, one at a time. Each issue gets a plan before any code exists. My architect agent reviews any design questions in the plan, and if an issue is too large to build in one pass, my pm agent proposes a split. Then Claude builds it, and other agents review the code and check it against the issue&#39;s acceptance criteria. By default the loop stops for my approval of every plan and every merge.</p><h3>The hardest part, still</h3><p>Fred Brooks said it in <a href="https://www.cs.unc.edu/techreports/86-020.pdf">No Silver Bullet</a> back in 1986: “The hardest single part of building a software system is deciding precisely what to build.” He went further. The builder’s most important function is the iterative extraction and refinement of requirements, because “the client does not know what he [or she] wants.”</p><p>Daniel Berry and Erik Kamsties, writing on <a href="https://cs.uwaterloo.ca/~dberry/ambiguity.res.html">ambiguity in requirements</a>, put it this way: “Often neither customers nor software developers recognize an ambiguity, and each derives an interpretation that differs from that of others without noticing this difference.” Two people read one sentence, formed two pictures, and neither recognized that their pictures differed.</p><h3>The developer in the middle</h3><p>For most of my career, developers took requirements from business stakeholders, then interpreted and debated them until an implementation plan settled. That’s where the ambiguity lived, and it was often the most work. Now developers are increasingly asked to write requirements too, for coding agents. That puts them in the middle, with a stakeholder on one side and an agent on the other. An ambiguity the developer misses coming in can go straight into the spec going out.</p><p>Research on the coding agent side agrees on one point: when detail is missing, agents tend to go ahead without asking. In <a href="https://arxiv.org/abs/2502.13069">Ambig-SWE</a> (ICLR 2026), which stripped detail from 500 real GitHub issues, the authors report that “without explicit prompting, models almost never interact, even for severely underspecified inputs.” A follow-up, <a href="https://arxiv.org/abs/2603.26233">Ask or Assume?</a> (EMNLP 2026), put a number on proceeding anyway: Claude Sonnet 4.5 resolved 54.8% of the issues with the detail withheld, against 70.8% with the full text. Anthropic’s own <a href="https://code.claude.com/docs/en/best-practices">Claude Code guide</a> says the same thing in product terms: “Claude tends to read a request conservatively and build the smallest thing that satisfies it, since it can’t see how much you were hoping for.”</p><p>These studies score the output against hidden tests, not against what a stakeholder wanted, and the “users” answering questions are other language models. So they show that the agent’s guess goes unflagged, not that it’s usually wrong, and you find it later, in the code. I call the agent a third reader of the requirement, after the stakeholder and the developer. The analogy is mine, extending Berry and Kamsties, who studied humans; no study I found compares the two.</p><h3>Single source of truth</h3><p>The practical answer is one set of requirement documents that the business stakeholders, the developer, and the agents all read. In my setup that is a PRD, epics, issues with acceptance criteria, and a decision log. An executive can read the PRD and its milestones. A product manager can read the epics and issues. The developer and the agents build from those same issues.</p><p>The documents also need a boundary between what gets built and how. GitHub’s <a href="https://github.com/github/spec-kit/blob/main/templates/commands/specify.md">Spec Kit</a> makes it a checklist item for the spec: “No implementation details (languages, frameworks, APIs).” The what is the business side’s to confirm. The how is the engineering team’s to choose. Mix them and a business reader can’t judge the document, and an engineer can’t tell which parts are negotiable.</p><p>The loop keeps that line structurally. The issue’s acceptance criteria are copied into the plan verbatim. The plan opens with who the work is for, before it gets to the approach. The architect reviews the approach and never writes to the repo. And if a plan would deliver less than a criterion asks, the engine treats that as an amendment to the issue: it records the change there and files the removed scope as a new issue, so nothing in the criterion gets dropped without a record. The engine stops at the issue, though. If the change alters what a milestone delivers, it belongs in the decision log and the PRD too, so the readers above the issue see it, and that step is on whoever approves the plan.</p><h3>The feature that passed every gate</h3><p><a href="https://github.com/frederick-douglas-pearce/agentfluent/issues/437">AgentFluent #437</a> proposed a scanner that would flag a pattern in the prompts users write for their own agents. Its motivation cited an <a href="https://www.anthropic.com/engineering/april-23-postmortem">Anthropic postmortem</a>, and the issue summarized it well enough that I didn’t reread the source during planning. The plan didn’t prompt me to, either, because nothing in it asked who the feature was for. The incident it cited had happened somewhere a user couldn’t touch.</p><p>The architect reviewed the plan, scoped to “regex correctness + currency, not a redesign,” and caught two acceptance criteria that contradicted each other (<a href="https://github.com/frederick-douglas-pearce/agentfluent/issues/437#issuecomment-4860023609">comment</a>). Easy fix. The feature was built and passed every technical gate. At the merge gate, which is mine, I read the source and wrote to Claude: “I don’t see how a user could benefit from this… Push back if I’m off base with a reasoned counter argument.”</p><p>I asked for a user-story mapping, and the pm agent ran a value review (<a href="https://github.com/frederick-douglas-pearce/agentfluent/issues/437#issuecomment-4861059604">comment</a>). It found two problems. The incident happened in Claude Code’s own system prompt, which the scanner can’t see, and the evidence was a single incident. A check of real agent configurations then found zero instances of the pattern. I closed the issue, and the pull request went unmerged (<a href="https://github.com/frederick-douglas-pearce/agentfluent/issues/437#issuecomment-4861228107">comment</a>). You don’t need the code to follow any of that. The question that exposed the problem was “who is this for?”, and the answer was in the source the issue cited.</p><p>Then I wrote the sentence that changed the engine: “I keep asking for user story mappings after a feature is complete and merged, but instead I think this should be delivered, at the planning gate.”</p><p>I had been asking the value question at the end of the line. That became AgentFluent #573, merged as PR #574 the same day, and it is where the engine’s value-first plan gate comes from. A feature plan now opens with a short user-story map: for each story, who benefits and how often real usage hits it.</p><p>Each story also carries a falsifier: an observation that would show the feature is misdirected. #437 had an obvious one. If the pattern the scanner hunts for almost never appears in real agent configurations, the feature has nothing to do, and checking that took one search. Nobody asked. Now the plan has to ask, and when the check is cheap, run it before any code exists. A feature plan maps one to three stories, each with its own falsifier. A plan that leans on an outside source also has to show the source supports the claim, including whether the problem occurs on the surface the feature inspects. That is #437’s lesson written as a rule. A plan with no credible user or no checkable falsifier goes back to the pm before anything is built.</p><p>It has stopped features since. In my election-data project, a proposed fix to the dashboard’s cache assumed visitors would request the same uncached page at the same moment. The plan checked a month of the dashboard’s own logs: 97 cache misses, and not one pair on the same page within 30 seconds. The pm recommended closing it, and I did, with no code written (<a href="https://github.com/frederick-douglas-pearce/us-presidential-vote-analysis/issues/333">#333</a>). In this plugin’s own repo, <a href="https://github.com/frederick-douglas-pearce/claude-code-loop/issues/30">another feature</a> was deferred at its plan gate: its evidence came to a single past instance, too thin to justify wording that would be copied into every new project’s config.</p><p>Watching this happen again and again is why I loop rather than vibe code. Prompting your way to a full-featured app in one go tends to skip the question of whether each feature should exist, and since the app may still work, the cost stays hidden until someone has to find the unneeded features and clean them up. Reviewing each issue as it lands also gives me context: I learn what each increment of value is and why it’s built the way it is, which lets me make good calls at the next plan and merge gates. If I never review the work from both the business and the engineering side, I don’t see how I can be an effective approver of it.</p><h3>What the field converged on</h3><p>Spec-driven development moves requirements out of the prompt and into files: a spec that says what to build and why, reviewed before any code is generated, and committed to the repo as the source of truth that people and agents both build from. Researchers at Carnegie Mellon University (CMU) and Google found spec files in <a href="https://arxiv.org/abs/2608.25202">73,030 public GitHub repositories</a>, almost all first committed in 2025 or later. Tools for writing specs range from a single interview prompt to full spec-to-code pipelines, but they agree on a short list of practices:</p><ul><li><strong>Interview before building.</strong> Matt Pocock’s <a href="https://github.com/mattpocock/skills/tree/main/skills/productivity/grill-me">grill-me</a> skill, through the grilling skill it calls, tells the agent to &quot;interview the user relentlessly until you reach a shared understanding.&quot; Anthropic&#39;s <a href="https://code.claude.com/docs/en/best-practices">Claude Code guide</a> has its own version, a prompt you type yourself: &quot;Interview me until you could write the spec, then write it to SPEC.md.&quot;</li><li><strong>Write intent to a file, and keep the what apart from the how.</strong> Spec Kit’s spec.md, Kiro&#39;s requirements-first flow (requirements.md before design.md), and OpenSpec&#39;s proposal.md do versions of this.</li><li><strong>Approval before code.</strong> The <a href="https://github.com/obra/superpowers">superpowers</a> framework: “Nothing gets built until your human partner approves the design doc.”</li><li><strong>Small tasks and a check to run.</strong> The Claude Code guide’s phrase is “Give Claude a check to run.”</li></ul><p>The evidence that any of this works is thin. Practitioners told the CMU team that specs made agent work more reliable, but they “could not separate this benefit from improvements in models.” One team reported spec-driven runs taking two to three times the tokens and about twice the time. The only controlled comparison I found, <a href="https://arxiv.org/abs/2604.05278">a preprint</a>, had another model grade the results on a 1-to-5 scale: 3.51 for the spec-driven runs against 3.46 without, even though the spec-driven runs were allowed 90 minutes each compared to the baseline’s 40.</p><p>The research also tends to measure how well the agent builds, not whether it’s building the right thing. Every controlled study I found fixes the what in advance, as a benchmark issue, a set of features, or a known bug, and scores the result. None asks whether the spec captured what the business needed, which is the problem this post is about. So treat the list as the field’s working consensus, not proven practice.</p><p>In grill-me and the Claude Code prompt alike, the person being interviewed is the developer, back in the middle. The interview builds a shared understanding between the developer and the agent, which is Berry and Kamsties’ problem one link down the chain. The business side is in it from the start, since that’s usually where the ask comes from, however it arrives. Its people should help shape the PRD, epics, and issues the interview produces, not just sign off on them, so the developer is translating in both directions.</p><h3>Where the loop fits, and where it doesn’t</h3><p>The dev loop already covers most of that list. Planning happens before code. Success criteria have to be testable, because a fresh verifier checks the diff against each acceptance criterion at the end. Work items are small, because an issue that won’t fit one context window is marked too large and sent back to be split. Context lives in files, and the plan gate is value-first.</p><p>The loop doesn’t elicit, though. It checks the what but never interviews you, and it starts from issues that already exist, so the thinking that put those words in the issue has to happen upstream.</p><p>I typically brainstorm a feature directly with Claude, then hand the conversation to my pm agent, outside the loop, to write the PRD, epics, and issues. An interview skill such as grill-me is a more structured version of that first step. That part is my practice, not the plugin’s, because the plugin ships no agents. SCOPE_AGENT names your own pm agent, if you have one. The flow I run is: elicit, write it into shared documents (PRD, epics, issues with acceptance criteria), then run the loop.</p><h3>Setting up work the loop can consume</h3><p>Each item below is something the engine reads, except the decision log, which is my practice rather than a requirement.</p><ul><li><strong>A GitHub milestone, epic, or label as the backlog.</strong> At the start of a run, the loop asks which backlog to run (a milestone, an epic or other label, or a TODO.md). If issues join or leave afterward, it asks you once and never changes the queue on its own.</li><li><strong>Issues sized to fit.</strong> If an issue plausibly spans many files or several unrelated clusters of criteria, the loop marks it blocked: too-large and sends it to your pm agent, which recommends a split for you to approve.</li><li><strong>Acceptance criteria someone can verify.</strong> They are copied verbatim into the plan, and the loop’s final verifier checks the diff against each one. For a feature, also name the user and the falsifier in the issue.</li><li><strong>Labels for routing.</strong> Your docs label and your research label route an issue, a “NOT implementation-ready” line in its body defers it, and priority labels set the order.</li><li><strong>Dependencies written down.</strong> The loop reads “Depends on” and “blocked by” in the issue body. An entry it can’t read as an issue reference counts as unmet.</li><li><strong>A decision log.</strong> The architect’s rulings need a home. The engine accepts an issue comment, an issue-body marker, or a decision-log entry. I prefer the log, because anyone can open it.</li></ul><h3>What the config settles</h3><p>Which labels mean what and which agents play the pm and the architect are settings in a per-project config file, along with merge and commit conventions. Whether you review every plan is set per run, and by default the plan gate stops for your approval. Post 4 walks through the config.</p><h3>Try this week</h3><p>You don’t need the plugin to try this out.</p><p>Take your next feature and run an interview-first prompt before anything else. Use grill-me, or the Claude Code guide’s “Interview me until you could write the spec” prompt from the list above. Write the result to a file and start a fresh session to build from it.</p><p>Then, before you approve the plan, ask for a user-story map: who benefits, how often they hit it, and what single observation would show this is the wrong thing to build. If the falsifier is cheap, ask for the check to be run now. If the agent can’t name a user, that is your answer, and it costs a few minutes instead of a merged feature.</p><h3>Next</h3><p>Shared documents only work if everyone means the same thing by the same words. That is the ba’s job, the role that keeps the pm, the architect, the implementer, and the humans from talking past each other. It isn’t in the plugin’s engine. So far, two of my projects have wired it in through their own configs. In my election-data project, the ba keeps the dashboard’s terms consistent from page to page and maintains a glossary for the site’s definitions page. It’s a single source of truth for terminology, the same idea as the requirement documents above. That’s Post 3.</p><p>This is Post 2 of <a href="https://frederick-douglas-pearce.github.io/blog/category/claude-code-loop/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=the-developer-in-the-middle&amp;utm_content=series">A Cross-Functional Team of One</a>.</p><p><em>Drafted with Claude Code (verified against v2.1.318). The ideas, claims, and any errors are mine.</em></p><p>Thanks for reading! I’m writing this series one gate at a time. Follow me here to get the next post.</p><p><a href="https://frederick-douglas-pearce.github.io/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=the-developer-in-the-middle&amp;utm_content=footer">Site</a> · <a href="https://github.com/frederick-douglas-pearce">GitHub</a> · <a href="https://www.linkedin.com/in/frederick-douglas-pearce/">LinkedIn</a></p><p><em>Originally published at </em><a href="https://frederick-douglas-pearce.github.io/blog/2026/the-developer-in-the-middle/"><em>https://frederick-douglas-pearce.github.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=2d56dd61a324" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[222 Votes Away, and a Record Few Can Get End to End]]></title>
            <link>https://medium.com/@fpearce/222-votes-away-and-a-record-few-can-get-end-to-end-4a941e8fc5be?source=rss-275a1bc818d2------2</link>
            <guid isPermaLink="false">https://medium.com/p/4a941e8fc5be</guid>
            <category><![CDATA[american-politics]]></category>
            <category><![CDATA[data-journalism]]></category>
            <category><![CDATA[elections]]></category>
            <category><![CDATA[american-history]]></category>
            <category><![CDATA[electoral-college]]></category>
            <dc:creator><![CDATA[Frederick Pearce]]></dc:creator>
            <pubDate>Mon, 09 Nov 2026 03:34:48 GMT</pubDate>
            <atom:updated>2026-11-09T23:18:51.024Z</atom:updated>
            <content:encoded><![CDATA[<h4>Every electoral vote back to 1824 and the popular vote from 1976 are now a public API you can question.</h4><p><em>Drafted with Claude Code, an AI coding tool, and edited by me. The ideas, claims, and any errors are mine.</em></p><figure><img alt="Title card for “222 Votes Away, and a Record Few Can Get End to End,” Post 1 of Counted, Not Assumed, with the subhead “Five times the person who took office had not led the popular vote count.” A list headed “Took office” names five elections: 1824 John Quincy Adams, 1876 Rutherford B. Hayes, 1888 Benjamin Harrison, 2000 George W. Bush, and 2016 Donald J. Trump. A second list, headed “Electoral vote, of electors appointed,” gives each one’s electoral votes in the same order: 84 of 261, 185 of 3" src="https://cdn-images-1.medium.com/max/1024/0*LpbBchU-7artnPZZ.png" /></figure><p>An agreement among American states already holds <a href="https://www.nationalpopularvote.com/state-status">222 of the 270 electoral votes</a> it would need to award the presidency to whoever wins the national popular vote. That’s 48 votes short, as of August 2026. Eighteen states plus the District of Columbia have enacted it, most recently Virginia, where Governor Abigail Spanberger signed it on April 13, 2026. Most people know about the Electoral College and its 270-vote threshold. Far fewer know this agreement exists.</p><p>It’s called the <a href="https://en.wikipedia.org/wiki/National_Popular_Vote_Interstate_Compact">National Popular Vote Interstate Compact</a>, and it works entirely inside a power the Constitution already gives each state: the authority to decide how it appoints its own electors. Join the compact, and a state agrees to appoint its electors for whoever wins the national popular vote, once enough other states have joined to reach 270. It needs no constitutional amendment. One legal question is still open: does Congress have to consent to an interstate agreement like this one under the Constitution’s Compact Clause? The <a href="https://crsreports.congress.gov/product/pdf/R/R43823">Congressional Research Service</a> has examined it and left it unresolved.</p><p>Whether it <em>should</em> take effect is a more interesting question, and one I can’t answer here. I’d rather put the record it turns on within reach of anyone who wants to dig into it, and leave the question itself to you: how should this country choose a president?</p><p>The argument over the compact runs on two centuries of election data that, as best I can tell, nobody has assembled publicly, for free, in one place a machine can read. I mean a source a dashboard, a notebook, or a piece of software can put a direct question to, without anyone first downloading a spreadsheet and wrangling it.</p><h3>The record the argument runs on top of</h3><p>The <a href="https://www.archives.gov/electoral-college/results">National Archives</a> keeps the Electoral College result for every presidential election, back to 1789. Election researchers keep the popular vote separately, in sources with their own coverage and their own conventions. Those two records were never built to sit next to each other. Comparing “who won the Electoral College” against “who won the popular vote” for any given year means someone has to take two documents built for different purposes and line them up state by state, candidate by candidate, year by year. As far as I’ve been able to find, a cleanly joined electoral-and-popular-vote dataset on one shared model, running back to 1824, doesn’t already exist as a public resource. That gap is what <a href="https://github.com/frederick-douglas-pearce/us-presidential-vote-analysis">this project</a> fills, and the joined record is meant to be useful in its own right, whatever anyone argues from it about NPVIC.</p><p>Five times in 47 presidencies, the person who took office had not led the national popular vote count: John Quincy Adams in 1824, Rutherford B. Hayes in 1876, Benjamin Harrison in 1888, George W. Bush in 2000, Donald Trump in 2016. 1824 is the odd one. No candidate held a majority of the electors <em>appointed</em>, so the House chose Adams under the Twelfth Amendment, a different mechanism than the other four, which are the more familiar shape: Electoral College winner, popular-vote runner-up. Whatever conclusion a reader draws about NPVIC has to hold up against each of those five cases on its own terms.</p><p>What’s public today stops at two different points. The Electoral College half of that record is public back to 1824: all 51 elections, state by state, checkable against a live <a href="https://api.us-presidential-election-center.org/docs">API</a>, down to the difference between the electoral votes that were cast and the ones Congress actually counted in the years those two numbers diverge. The popular-vote half reaches back only to 1976. That boundary comes from licensing: the returns exist much further back, but the source I’m free to redistribute, the <a href="https://doi.org/10.7910/DVN/42MVDX">MIT Election Lab</a>, starts there.</p><p>So the comparison lands unevenly on the five cases above. For 2000 and 2016, both halves of it are checkable end to end. For 1824, 1876, and 1888, the electoral result is there (ask about 1888 and you get Harrison 233, Cleveland 168, out of 401), and the popular-vote half of the claim is not. It exists, in the project’s own warehouse, from the source I’m not free to republish; it just isn’t something I can hand you. Both windows are published on every response that carries data, at meta.provenance.coverage, so you don&#39;t have to take my word for where they stop. And every state row carries a status saying whether a popular vote was held there at all, which is what turns 1824&#39;s six legislature-appointed states from a caveat I&#39;m asking you to accept into a fact you can look up.</p><h3>Why 1824, and not a tidier year</h3><p>The election of 1824 is also where the comparison has to start. Setting the Electoral College result beside the popular vote needs two things at once: enough states holding a popular vote for the total to mean anything, and a contest close enough that the two records might disagree. 1824 is the first year both are true. Eighteen of its twenty-four states chose electors at the ballot box, and the race was genuinely open: four candidates took electoral votes, and the leader finished with 99 of 261. Four years earlier, Monroe had taken all but one of the electoral votes cast; when the two records agree that completely, lining them up doesn’t say much.</p><p>All of which makes 1824 the messiest year in the set, and a cleaner starting point does exist a few cycles later, once every state runs a popular vote and the Electoral College winner simply takes office. But the tidy years are tidy because of what happened in the untidy ones, and a record that begins after the mess can’t show you that.</p><h3>What makes it worth building an argument on</h3><p>The record isn’t complete, and two centuries of American elections were never going to be documented the way a modern one is. The test for building an argument on it is whether it is honest about the difference between <em>we don’t know</em> and <em>the answer is zero</em>. A state that held no popular vote at all is not the same fact as a state that held one in which a candidate got zero votes. Collapse those two into the same number and you’ve asserted something about American history that isn’t true.</p><p>This is Post 1 of <a href="https://frederick-douglas-pearce.github.io/blog/category/us-presidential-vote/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=222-votes-away&amp;utm_content=series">Counted, Not Assumed</a>. The next post takes that distinction on directly. A record has to be able to say which of the two happened before anyone can draw a conclusion from it, about NPVIC or anything else.</p><p><em>Drafted with Claude Code. The ideas, claims, and any errors are mine.</em></p><p>Thanks for reading! I’m writing this series one slice of history at a time, counted rather than assumed. Follow me here to get the next post.</p><p><strong>Update, November 2026</strong>: after the midterms, five states outside the compact have new Democratic trifectas (unofficial until certified). The arithmetic is in a follow-up post: <a href="https://frederick-douglas-pearce.github.io/blog/2026/compact-arithmetic-after-midterms/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=compact-arithmetic-after-midterms">222 Plus Five States: The Compact’s Arithmetic, as of November 2026</a>.</p><p><a href="https://frederick-douglas-pearce.github.io/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=222-votes-away&amp;utm_content=footer">Site</a> · <a href="https://github.com/frederick-douglas-pearce">GitHub</a> · <a href="https://www.linkedin.com/in/frederick-douglas-pearce/">LinkedIn</a></p><p><em>Originally published at </em><a href="https://frederick-douglas-pearce.github.io/blog/2026/222-votes-away/"><em>https://frederick-douglas-pearce.github.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=4a941e8fc5be" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[A Loop to Remember]]></title>
            <link>https://medium.com/@fpearce/a-loop-to-remember-f49cadd70c72?source=rss-275a1bc818d2------2</link>
            <guid isPermaLink="false">https://medium.com/p/f49cadd70c72</guid>
            <category><![CDATA[ai]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[software-development]]></category>
            <dc:creator><![CDATA[Frederick Pearce]]></dc:creator>
            <pubDate>Sat, 24 Oct 2026 08:25:00 GMT</pubDate>
            <atom:updated>2026-10-24T08:25:00.078Z</atom:updated>
            <content:encoded><![CDATA[<h4><em>Giving coding agents the structure human teams rely on.</em></h4><p><em>Drafted with Claude Code, an AI coding tool, and edited by me. The ideas, claims, and any errors are mine.</em></p><figure><img alt="Title card for “A Loop to Remember”: an agent can do every job on a dev team, but it shouldn’t check its own work. Two panels compare the dev process without the loop, with every handoff typed by hand, and with it, where the architect, code review, acceptance check, mutation testing and record each run by the issue’s route." src="https://cdn-images-1.medium.com/max/1024/1*mJieThz11Smzox6EydUp0g.png" /></figure><p>Early on with Claude Code, the least reliable member of my AI dev team was me.</p><p>I was building AgentFluent, a tool for monitoring and improving how well Claude Code subagents perform, and I already had an agent team of sorts. A pm agent scoped the work. An architect agent reviewed the design. Claude, running as the main or “parent” agent, wrote the code, opened the PRs and ran the reviews via a separate skill. Every handoff between them happened because I typed it, and nothing was journaled outside GitHub issues and PRs.</p><p>I thought it was working pretty well, but I had to babysit every step, and it was more error-prone than I cared to admit. I often forgot to bring the architect in until a plan was already written, or, occasionally, not until the implementation was underway. I hedged and told Claude to bring the architect in “if needed,” without giving it criteria to evaluate, so design reviews were inconsistent.</p><p>Nothing in the process checked the finished work against what the issue had actually asked for. Were all the tests really testing something? I wasn’t always sure.</p><p>One night, with a release’s worth of issues still in the queue, I decided it was time to automate the process so I didn’t have to prompt each step by hand. Forgetting was a symptom. The problem was that there was a lot to remember. I needed a loop to remember for me.</p><p>A few weeks later I wanted the same loop on another project, so I packaged it as a Claude Code plugin, dev-loop, that any repo can install.</p><h3>Why teams have roles</h3><p>The complaints developers make about coding agents are many of the same ones developers have always made about each other, and teams fixed them with structure and process, not with better individuals.</p><p>In <a href="https://survey.stackoverflow.co/2026/ai/data">Stack Overflow’s 2026 survey</a>, the biggest group of developers rated their AI tools “good, but not great” at complex tasks, and nearly half said they trust AI output only when they can easily check it. Checking has become the slow part. When one company moved its engineers to Claude Code, AI-written pull requests were no buggier than human-written ones by the study’s measures, but each reviewer’s load doubled ( <a href="https://arxiv.org/abs/2607.01904">He et al., 2026, preprint</a>). Human teams hit the same wall whenever one person writes faster than the others can review.</p><p>Context has changed shape too. Today’s agents can search the whole repo, and in <a href="https://survey.stackoverflow.co/2026/knowledge/data">the same survey</a> only one developer in five said a lack of context in AI tools got in their way. The context developers say they need most isn’t in the code: 85% named project goals or requirements, 44% earlier decisions and the reasons behind them, and 61% said important context lives in people’s heads. A new hire has the same problem on day one. They can read every file and still not know why it was built that way, so we pair them with someone who knows the system.</p><p>Now take the best model you can imagine. It still has to get requirements clarified. It still needs scope split into pieces that can be reviewed. It still needs to know the design principles and the roadmap, which are not in the files it is editing. That work is some of the hardest in development, and it sits where roles meet: the pm and the implementer on requirements, the architect and the implementer on design. Teams put a handoff at each of those points.</p><h3>A cross-functional team of one</h3><p>An agent can do every job on a dev team. What it shouldn’t do is check its own work.</p><p>That is the thesis behind the series title, “A Cross-Functional Team of One.” A coding agent really is cross-functional. It plans, designs, implements and tests. Generalization means a lot of ground to cover, and when the same mind that did the work also checks it, it tends to confirm its own thinking.</p><p>Covering all that ground has a cost of its own. Everything the agent reads lands in one context window, and Anthropic’s Claude Code guide warns that it “fills up fast, and performance degrades as it fills.” The guide’s answer is a subagent with its own fresh context, “so the agent doing the work isn’t the one grading it” ( <a href="https://code.claude.com/docs/en/best-practices">Claude Code docs</a>).</p><p>The architect in my setup works read-only. It never writes code. What it does is add the context the parent lacked: other modules, the roadmap, edge cases, the design principles the parent wasn’t prioritizing while it chased the task. A reviewer in a different role, human or AI, sees different inputs and weighs them by their own responsibilities.</p><h3>How I work now</h3><p>I’m the team’s owner: I make the final call on scope, design and what merges. I usually start by brainstorming with the parent agent, then hand the agreed-upon spec to the pm agent, which scopes the work together with the architect. Questions come back to me. The pm produces the PRD, the epics and stories, and recommendations on priority and milestones. It also starts a decision log, which records the architect’s rulings and my own calls as well as its own.</p><p>The dev-loop plugin then works the top epic&#39;s issues one by one. I approve every plan and every merge. The architect&#39;s design calls come to me inside the plan. The review gates run without me, and when the reviewers can&#39;t settle a finding, or a finding raises a design question, they stop and hand me options. If my priorities change, say I need a release out sooner, I talk it through with the pm, and we reorder the backlog and re-scope issues to match.</p><p>The roles are:</p><ul><li><strong>pm</strong> scopes and prioritizes.</li><li><strong>architect</strong> reviews design, read-only.</li><li><strong>ba</strong> keeps a glossary so the other roles stop talking past each other. It is wired into two of my projects’ loop configs. It is not yet in the plugin’s engine, so installing dev-loop will not give it to you.</li><li><strong>implementer</strong> writes the change.</li><li><strong>code review</strong> is an independent pass over the diff, with the issue’s acceptance criteria in hand.</li><li><strong>security</strong> is the specialist on call. It reviews code changes that touch a security-sensitive surface and sits out the rest, and any change that touches such a surface comes to me at merge regardless.</li><li><strong>QA</strong> checks the work against the issue’s acceptance criteria. On code changes that come with tests, it then runs mutation testing, which catches tests that pass without testing anything.</li><li><strong>merge</strong> is the last gate, and it is mine.</li></ul><p>Map the complaints to the roles. “Doesn’t know my codebase” goes to the architect. Scope creep goes to the plan gate. “Tests pass, doesn’t work” goes to QA. Misreadings or inconsistent language between roles go to the ba. The one I haven’t solved is over-engineering. It’s still on me to catch, but every feature plan now has to say who it’s for and what would show it’s the wrong thing to build, and a plan that can’t stops at the plan gate.</p><p>Plans change when these roles weigh in. On August 15, the v0.2.0 milestone had 13 open work items. In the previous 15 days, 19 issues had closed and 31 had been filed. I asked for a pm review, and the verdict was “Ship 5 work items, not 13.” It also recommended freezing the milestone. The milestone shipped four days later.</p><p>On October 8, I wanted an executive-level brief built on top of per-PR briefs. Two other aggregator ideas were already open in the backlog. The architect recommended combining them rather than building three aggregators. It also reversed my plan to commit the briefs to the repo. Committing them on the feature branch was out, because “the brief becomes part of the diff it describes.” I took both.</p><p>I don’t always take the advice. I kept open an issue the pm wanted closed, and shipped the architect’s version of a change the pm wanted deferred.</p><p>Agents are agreeable. They won’t push back forcefully unless you ask them to, and that cuts both ways: you may have to encourage disagreement, but that’s cheap. A pm and an architect can disagree in parallel in minutes. I still decide.</p><h3>What it gives me</h3><p>Process, first of all. The loop runs every step the issue’s route calls for, in order, every time. I no longer worry about forgetting to bring in the architect or run the review, because remembering is the loop’s job now.</p><p>It remembers across sessions, too. Its state lives in a ledger on disk, so a /clear, a compaction or a crash doesn&#39;t lose my place. On resume, the loop checks each unfinished item against git and the open PRs before it starts anything new. And it fails safe: a gate it didn&#39;t run never counts as passed, and a missing setting never turns a check off.</p><p>It also replaced my old “if needed” with written criteria. Each issue is routed by its labels and by path rules in the project’s config. A code change goes through the full pipeline. A docs-only change skips the architect and security passes and gets a lighter review, which saves time and tokens.</p><p>And it travels. My projects are very different: some are almost all markdown, like the plugin itself; some are web apps; and some are Python command-line tools. Each has its own loop config, loop.config.md, which sets the test and lint commands, the routing rules, and which agent fills each role. The engine ships separately, as the plugin, so when it gains a feature, such as changes aimed at cutting its token cost, every project gets it on update while its config stays its own.</p><p>I trust the output more, because the work is checked by an agent in a different role, not by its author. I learn more, because the architect and pm explain their reasoning and I read it. I have a pm available at any hour, on every project I run. And I have shared artifacts, the decision log and the glossary, that a human teammate can open, read and comment on.</p><h3>Where it’s going</h3><p>This part is opinion, not a finding.</p><p>I think developers are becoming owners of agent teams, accountable for what those teams produce. That doesn’t retire what human teams have learned. Agent teams should be modeled on human ones and work in sync with the human PMs, architects and reviewers who hold the same roles.</p><p>The mechanism for tailoring that team is the loop config plus custom agents. Each role is bound in the config, and the pm and architect are bound by agent name, as SCOPE_AGENT and DESIGN_AGENT. Pointing one of those at a different agent definition is all a tailored role needs. So when a human PM reviews the artifacts and gives feedback, that feedback can become a tweak to the pm agent or a change to the loop config. Across projects and orgs, each loop could be tailored to the individuals on that team.</p><p>My projects to date are personal, so no human PM has sent me that feedback yet. The binding exists today; the cross-org use is my vision for the dev loop.</p><p>I’ve heard plenty of developers say, “Building software is easy. Just give us the exact specs.” Now the developer is increasingly the one who has to write them.</p><h3>Try this week</h3><p>List the handoffs you type by hand every session. “Loop in the architect.” “Run the review.” “What’s next?” Each one is a role, and each is a place where you are the only one keeping the process on track.</p><p>If you want to evaluate how well your own subagents work, that is what <a href="https://github.com/frederick-douglas-pearce/agentfluent">AgentFluent</a> is for.</p><p>The dev-loop plugin and the loop config are at <a href="https://github.com/frederick-douglas-pearce/claude-code-loop">claude-code-loop on GitHub</a>.</p><p>This is Post 1 of <a href="https://frederick-douglas-pearce.github.io/blog/category/claude-code-loop/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=a-loop-to-remember&amp;utm_content=series">A Cross-Functional Team of One</a>. The rest of the series goes gate by gate: how each role works, the real runs where one nearly let something through, and what I changed in the loop afterward. It also covers how to set up the loop for your own projects, and the cost experiments aimed at making it cheaper without making it weaker. Write your process down once, and let the loop do the remembering.</p><p><em>Drafted with Claude Code (verified against v2.1.306). The ideas, claims, and any errors are mine.</em></p><p>Thanks for reading! I’m writing this series one gate at a time. Follow me here to get the next post.</p><p><a href="https://frederick-douglas-pearce.github.io/?utm_source=medium&amp;utm_medium=social&amp;utm_campaign=a-loop-to-remember&amp;utm_content=footer">Site</a> · <a href="https://github.com/frederick-douglas-pearce">GitHub</a> · <a href="https://www.linkedin.com/in/frederick-douglas-pearce/">LinkedIn</a></p><p><em>Originally published at </em><a href="https://frederick-douglas-pearce.github.io/blog/2026/a-loop-to-remember/"><em>https://frederick-douglas-pearce.github.io</em></a><em>.</em></p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f49cadd70c72" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>