Leaving the Agentic Bicycle Era: What comes after Claude Code? 🔗 **Source:** [Leaving the Agentic Bicycle Era: What comes after Claude Code?](https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code) > [!note]+ Document Notes > tags: [AI, software-development, agentic-coding] > author: Keep Websites Weird > source: Keep Websites Weird > reference: [https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code] > date created: 2026-02-15 10:00 > > # 🏷️ Title: Leaving the Agentic Bicycle Era: What comes after Claude Code? > <!-- deep-read:sections start --> ## 🧭 Table of Contents - [📝 Summary](#-summary) - [📖 Main Content](#-main-content) - [🗒️ Notes](#️-notes) - [📚 References](#-references) - [🗣️ Paraphrase](#️-paraphrase) - [📰 Newsletter](#-newsletter) - [✅ Action Items](#-action-items) - [🧪 Hypotheses](#-hypotheses) - [📊 Methodology](#-methodology) - [❓ Questions](#-questions) - [🔮 Future Research](#-future-research) - [💡 Implications](#-implications) - [🧠 Learning Styles Assessment](#-learning-styles-assessment) - [📊 Accessibility Assessment](#-accessibility-assessment) - [🌍 DEIB Assessment](#-deib-assessment) - [✅ Logical Validity](#-logical-validity) - [🛡️ DARVO Analysis](#-darvo-analysis) - [🎯 Conclusion](#-conclusion) ### 🔗 References - Include links cited in or relevant to the article. ## 📝 Summary - The author argues we’re in a “bicycle” / early “automobile” era of agentic coding, where LLMs speed up humans rather than replace them, and points toward an industrial “orchestration” era focused on fleets of agents rather than single agents. - It matters because it reframes AI coding tools from personal productivity (one dev + one agent) to organizational-scale automation and coordination. - Key stakeholders: software engineers, tooling vendors, AI researchers, engineering leaders, and future “agent orchestrator” roles. - Risks/tradeoffs: reliability, safety, cost, infrastructure standards, and the temptation to chase full autonomy (no human in the loop) where that’s neither workable nor desirable. - Bottom line: the next big shift isn’t smarter single models but systems for coordinating many agents at scale, with humans supervising systems rather than individual code edits. ## 📖 Main Content - The author compares today’s LLM coding tools to a “bicycle era”: tools like GitHub Copilot and Cursor speed up manual coding by providing completions and task-level agents while humans still stay “hands-on in the code” and responsible for checking and editing results ([intro analogy](https://read.readwise.io/read/01kgnqbmq9zc8eqqsbdp0t6nk2?endLexposition=00008_00000-0058&startLexposition=00000&emphasizeText=The+bicycle+era+for+coding+with+LLMs+started+with+tab+completions+in+the+OG+CoPilot+days)). - An “early automobile” phase shifts focus from asking LLMs to do specific tasks to specifying outcomes; tools like Claude Code embody this by hiding the “code engine” under the hood while humans steer and intervene mainly when things go wrong ([early automobile metaphor](https://read.readwise.io/read/01kgnqbmq9zc8eqqsbdp0t6nk2?endLexposition=00008_00000-0058&startLexposition=00000&emphasizeText=The+point+at+this+stage+though+is+that+LLM+instructions+are+focused+on+outcomes+instead+of+tasks)). - Current experimentation around harnesses, loops, and tools like Ralph and OpenClaw shows people “trying to get the motor running” but facing predictable automation hurdles: reliability, efficiency, cost, and safety, with no Model T–like standardization or robust “roads” (infrastructure and protocols) yet ([motorized experiments](https://read.readwise.io/read/01kgnqbmq9zc8eqqsbdp0t6nk2?endLexposition=0000A_00000-009T&startLexposition=0000A&emphasizeText=People+are+looking+for+a+way+to+get+the+motor+running)). - The public imagination often jumps straight to fully “self‑driving” agents that remove humans entirely and “take all the jobs”; the author argues this vision is flawed because most real systems will still require a clearly accountable human to supervise and be trusted or blamed when things go wrong ([human-in-the-loop argument](https://read.readwise.io/read/01kgnqbmq9zc8eqqsbdp0t6nk2?endLexposition=0000K_00000-008C&startLexposition=0000C&emphasizeText=I+don%E2%80%99t+think+a+no-human-in-the-loop+state+will+ever+be+functional+or+desirable)). - The more important missed idea, they argue, is that focusing only on making an individual developer faster is too narrow; the frontier is orchestrating groups or “fleets” of agents, similar to “Starcraft” or “Factorio” gameplay where the challenge is to manage complex systems rather than micromanage units ([orchestration phase](https://read.readwise.io/read/01kgnqbmq9zc8eqqsbdp0t6nk2?endLexposition=0000Q_00000-0055&startLexposition=0000M&emphasizeText=As+orchestration+tools+continue+to+develop%2C+I+think+we+enter+a+new%2C+industrial+phase+of+coding+with+LLMs)). - In this “industrial” or orchestration era, humans focus on designing macro‑systems, setting large‑scale input/output parameters, and coordinating many agents, not just tweaking individual prompts or reviewing line‑by‑line code; there will still be mechanical interventions, but they’ll be leveraged where they impact overall system efficiency most. - This shift will create new job descriptions that don’t map neatly to current engineering roles; some engineers will excel, but engineering background alone won’t be necessary or sufficient for orchestrating complex agentic systems ([new roles insight](https://read.readwise.io/read/01kgnqbmq9zc8eqqsbdp0t6nk2?endLexposition=0000U_00000-007h&startLexposition=0000S&emphasizeText=Rather+than+being+a+threat+to+current+jobs%2C+this+kind+of+work+will+require+titles+and+descriptions+that+don%E2%80%99t+exist)). - Technically, this also reframes progress: instead of purely “vertical” scaling (making single models ever more capable), the real open frontier is “horizontal” scaling—coordination, collaboration, and composition across many agents, where the space of possibilities is “just starting to open up” ([horizontal vs vertical scaling](https://read.readwise.io/read/01kgnqbmq9zc8eqqsbdp0t6nk2?endLexposition=0000U_00000-007h&startLexposition=0000S&emphasizeText=this+represents+a+shift+from+scaling+LLM+capabilities+vertically)). ### 🗒️ Notes - “Bicycle era” = LLMs as power‑assist for manual coding: tab completions, local refactors, one‑off tasks, human review and edits at every step. - Tools like Cursor fit this mode: you might “not write a single line yourself,” but you’re still immersed in the code, requesting specific completions and iterating on them. - “Early automobile” = outcome‑focused prompting where the code engine is hidden; humans set goals and nudge, but intervene mainly on failure or misalignment. - Harness tool experiments (e.g., loops, action graphs) currently wrestle with basic automation problems: getting stable behavior, keeping costs controlled, handling failures. - Infrastructure is immature: we lack standard safety devices (equivalents of seatbelts/airbags), and the “roads” (protocols, shared conventions) are rough and fragmented. - The author resists the narrative of fully autonomous agents replacing humans; organizational, legal, and trust reasons will keep humans in the loop as responsible parties. - They emphasize that imagination is constrained if we only see AI as a “faster individual dev”; the more transformative shift is system‑level orchestration. - Orchestration = designing, monitoring, and tuning fleets of agents across workflows, teams, or entire organizations, with humans managing flows not just units. - Analogies like “Starcraft” or “Factorio” highlight resource planning, pipelines, and emergent complexity rather than micro‑interactions with a single model. - This “industrial phase” introduces new roles (e.g., agent operations, AI systems orchestrator) that blend technical, product, and operations mindsets. - Progress narrative: individual models may be nearing capability limits; big gains may come from how we connect, govern, and coordinate many agents instead. ## 📚 References - Keep Websites Weird — “Leaving the Agentic Bicycle Era: What comes after Claude Code?” (original article): https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code - Anthropic Claude Code (example of outcome‑focused agentic coding): https://www.anthropic.com/news/claude-code - GitHub Copilot (example of “bicycle era” assistance): https://github.com/features/copilot ## 🗣️ Paraphrase - The author says we’re moving from using AI as a simple coding assistant (like a bicycle that makes you faster but still depends on your pedaling) toward more automated systems (like early cars) that hide complexity but still need hands on the wheel. - They argue the real future is not fully autonomous agents replacing humans, but large‑scale orchestration of many agents, where humans design and oversee complex AI systems that act like industrial fleets rather than lone coders. ## 📰 Newsletter AI is changing how we build on the web, and this piece on the “agentic bicycle era” of coding hits close to home for the WordPress ecosystem. We’re already using Copilot‑style tools to scaffold plugins, block themes, and custom integrations—but the next wave looks like orchestration: fleets of agents coordinating tests, content workflows, and deployments across multisite networks. For WordPress builders, this suggests two tracks: first, keep sharpening your “bicycle” skills with AI‑assisted coding and site building; second, start experimenting with system‑level automation—e.g., using AI for regression triage, pattern inventory management, and content QA at scale. Keep an eye on: - Emerging AI‑powered CI/CD integrations for WordPress. - Tools that coordinate multiple LLM agents for plugin security review and documentation. - Community experiments around using agent fleets to manage large networks or editorial pipelines. This isn’t about replacing developers; it’s about shifting from writing every line to designing and supervising the systems that do. ## ✅ Action Items #### DevRel - Map today’s “bicycle era” AI tools (Copilot, Claude Code, etc.) to your current developer workflows and document example use cases. - Design workshops that help developers move from task‑level prompting to outcome‑focused flows (e.g., “build and refactor a feature end to end with agents”). - Create tutorials showing orchestration patterns: multiple agents for tests, docs, and refactors across a single codebase. - Track adoption metrics: number of teams using AI in PR review, test generation, or release prep. #### OSPO - Draft guidelines for human‑in‑the‑loop oversight of AI‑generated code in open source projects. - Establish contribution policies clarifying when and how agentic tools can be used and how to disclose them. - Pilot SBOM and license‑compliance checks that account for AI‑generated components. - Explore upstream funding for orchestration tooling that helps maintainers manage fleets of agents safely. #### Community - Host discussions on how maintainers can use AI as “bicycles” and, eventually, as orchestrated fleets, without burning trust. - Run contributor sprints where participants experiment with AI‑assisted triage and documentation, then share what worked. - Encourage sponsors to support infrastructure (testing, observability, orchestration layers) rather than only individual productivity tools. - Coordinate cross‑project tabletop exercises around AI‑driven incidents and recovery. #### WordPress - Core: Explore small “agent in the loop” experiments for issue triage and patch suggestion, always with clear human review boundaries. - Core Performance: Use AI to generate and maintain performance regression test suites and dashboards. - Core AI: Define responsibility lines and eval sets for any proposed orchestrated agents around .org infra or core workflows. - Core Program Team: Align release cycles with experimental AI tooling so that agent‑generated changes are safely scoped and reversible. - Mobile: Prototype AI‑assisted UX reviews and regression checks across device matrices. - Playground: Build sandboxes for experimenting with multi‑agent orchestration scenarios in a safe, browser‑based environment. - Community: Provide meetup kits to discuss AI “bicycle vs. orchestration” concepts and local experiments. - Training: Add lessons on prompt patterns, review practices, and early orchestration fundamentals. - Marketing: Shape narratives around “WordPress + AI as leverage, not replacement,” highlighting human-in-the-loop stories. - Support: Document best practices for using AI to draft answers that moderators then refine, not rubber‑stamp. - Design: Investigate AI‑assisted pattern libraries and internal design audits driven by orchestrated checks. - Documentation: Track AI’s role in docs generation; standardize review flows and attribution guidelines. - Photos / TV / Polyglots / Accessibility / Meta / CLI / Hosting / Tide / Openverse / Themes / Plugins: - Explore where “bicycle” AI can reduce repetitive work (captioning, translations, basic audits). - Identify a few candidate workflows that could later benefit from orchestration (e.g., coordinated translation updates, plugin review pipelines). #### The WPOCC - Frame fellowships and microgrants around experimentation with safe, human‑supervised AI orchestration in WordPress projects. - Sponsor governance clinics on how to integrate agentic tools without displacing maintainers. - Pilot funding for observability and safety tooling that makes agent orchestration auditable in open-source communities. ### FAIR - Encourage architectures where orchestration metadata (who did what, which agents ran when) remains locally inspectable. - Promote transparent funding for AI tooling and clear sunset clauses for experimental orchestrators. - Develop reusable templates for governance of multi‑agent systems in open communities. ## 🧪 Hypotheses - H1: Teams using agent orchestration (multiple agents coordinated with human oversight) will achieve higher throughput than teams relying solely on single‑agent “bicycle” tools. - H2: Human‑in‑the‑loop oversight will remain necessary in production software systems despite increasing agent autonomy. - H3: The primary productivity gains over the next five years will come from horizontal scaling (coordination of agents) rather than vertical scaling (more capable single models). - H4: New job roles focused on agent orchestration will emerge and will not correlate one‑to‑one with traditional engineering backgrounds. ### 📊 Methodology - For H1/H3: Run controlled comparisons between teams using single‑agent tools and teams using orchestrated multi‑agent setups on standardized software tasks; measure throughput, error rates, and time‑to‑fix. - For H2: Survey and case‑study production systems that attempt high autonomy; catalog failure modes and governance requirements; analyze legal and organizational accountability demands. - For H4: Longitudinal labor‑market analysis tracking job postings, required skills, and backgrounds for AI orchestration and “AI ops” roles across industries. ### ❓ Questions - What kinds of software systems can safely minimize human oversight, and which absolutely cannot? - How should accountability be structured when a fleet of agents contributes to a production change? - What new abstractions (languages, dashboards, orchestration frameworks) will we need to manage many agents? - How will education and training adapt to prepare people for orchestrator roles instead of only developer roles? ### 🔮 Future Research - Formal models of multi‑agent orchestration for software delivery pipelines. - Human‑factors research on cognitive load when overseeing fleets of agents vs. single‑agent tools. - Governance and audit frameworks for AI‑driven development processes in regulated industries. - Economic impact studies of shifting from individual productivity tools to organizational orchestration. ### 💡 Implications - Practice: Developers will increasingly design and supervise systems of agents rather than directly writing all code. - Policy: Regulators may require identifiable human supervisors for critical AI‑driven systems. - Security: Attack surfaces expand as more agents operate semi‑autonomously; orchestration layers become critical control points. - Education: Curricula may add orchestration, system‑level thinking, and human‑AI collaboration patterns. - Funding: Investment may tilt from pure model research to orchestration platforms, safety layers, and observability. ### 🧠 Learning Styles Assessment - Reading level estimate: Roughly college/early professional; concept density and metaphors likely put it around Grade 12–14 (e.g., Flesch‑Kincaid). #### 👀 Visual learners - Present: Conceptual metaphors (bicycles, cars, Starcraft, Factorio) that can be visualized. - Improve: Diagrams of “bicycle vs. automobile vs. orchestration” stages, and architecture sketches of multi‑agent systems. #### 🔊 Aural learners - Present: None intrinsic. - Improve: Short audio summary or podcast‑style discussion of the metaphors and implications. #### 🗣️ Verbal learners - Present: Clear analogies, narrative progression from present to future, defined contrasts (vertical vs. horizontal scaling). - Improve: Glossary of agentic coding terms and more explicit definitions of example tools. #### 🧩 Kinesthetic learners - Present: Implicit prompts to “imagine using” various tools. - Improve: Hands‑on labs: set up a bicycle‑style workflow vs. a simple orchestrated multi‑agent workflow. #### 🧠 Logical learners - Present: Stepwise reasoning from current usage to future orchestration, causal arguments about human oversight. - Improve: More explicit argument maps, timelines, and comparative tables of different eras. #### 🧑‍🤝‍🧑 Social learners - Present: Topic is well‑suited for group debate. - Improve: Discussion questions and scenarios for teams to explore how they’d adopt orchestration. #### 🧘‍♀️ Solitary learners - Present: Reflective, speculative style encourages independent thought. - Improve: Reflection prompts at the end: “Where is my work on this spectrum? What experiments could I run?” #### 🌿 Naturalistic learners - Present: Limited. - Improve: Analogies to ecosystems (agents as species, orchestration as ecology management) and sustainability angles of computation and automation. ### 📊 Accessibility Assessment #### Screen reader semantics - Present: Depends on site implementation; conceptually, headings can be well structured. - Improve: Ensure proper heading hierarchy and descriptive link text; avoid generic “click here.” #### Keyboard navigation - Present: Standard article likely mostly navigable. - Improve: Guarantee skip links, logical tab order, and visible focus indicators. #### Contrast and readability - Present: Unknown; typical blog themes vary. - Improve: Verify 4.5:1 contrast ratios, comfortable line length, and spacing. #### Text resizing and reflow - Present: Likely responsive. - Improve: Test at 200% zoom and with reduced‑motion preferences; ensure no clipping of code or diagrams if added later. #### Media and captions - Present: Text only. - Improve: If adding diagrams or video explainers, include alt text, captions, and transcripts. #### Forms and interactions - Present: Minimal, likely just navigation and comments. - Improve: Ensure form labels, error messages, and target sizes meet WCAG 2.2 AA. #### Standards reference - Map gaps to WCAG 2.2 AA criteria such as 1.4.x (contrast), 2.1.x (keyboard), 2.4.x (navigable), and 3.3.x (input assistance). ### 🌍 DEIB Assessment #### Cultural breadth - Present: Tech‑centric, largely Western tooling references. - Improve: Include examples from diverse regions and smaller ecosystems, and consider varying infrastructure constraints. #### Inclusive language - Present: Neutral, non‑gendered, relatively low jargon. - Improve: Add plain‑language summaries and define niche tooling terms for wider audiences. #### Neurodiversity support - Present: Clear metaphors and chunked sections by idea. - Improve: More explicit headings, summaries, and consistent patterns for readers who benefit from structure. #### Representation - Present: Focus on roles, not people; no explicit imagery. - Improve: If adding visuals, ensure diverse and respectful representation. #### Psychological safety - Present: Non‑alarmist tone; counters job‑loss apocalyptic narratives. - Improve: Add guidance on responsible experimentation and avoiding burnout in rapid‑change environments. ### ✅ Logical Validity #### Strong reasoning - Uses analogical reasoning (bicycle → automobile → industrial/orchestration) to clarify how capabilities and roles change over time; this is consistent and helps readers categorize tools and phases. - Presents a plausible causal argument that horizontal scaling (coordination) can be more impactful than further vertical scaling of single models, supported by anecdotal input from technically informed sources. #### Fallacies - Some reliance on anecdotal evidence (“folks who are closer to the technical details have told me…”) could be strengthened with empirical data; currently it risks argument from authority but is framed as impressionistic, not definitive. - Speculative claims about future roles and limits of autonomy are reasonable but not empirically grounded; they could be clarified as hypotheses. #### Tone of voice - Reflective, exploratory, and mildly opinionated; uses playful metaphors (“Starcraft,” “Factorio”) and avoids hype or doom. ### 🛡️ DARVO Analysis - Deny: No clear denial of specific harms; the piece acknowledges risks (reliability, safety, cost). - Attack: No attacks on critics or individuals; disagreements with “self‑driving agents will take all jobs” narratives are framed conceptually, not personally. - Reverse victim/offender: No attempt to reframe powerful actors as victims; the piece focuses on system design and roles, not interpersonal conflict. ## 🎯 Conclusion The article argues that we’re leaving a “bicycle” era of AI‑assisted coding for an “automobile” phase and, ultimately, an industrial orchestration era where humans supervise fleets of agents rather than single tools. Practically, readers should experiment with AI as leverage today while beginning to think in terms of system‑level orchestration, human accountability, and the new roles that will emerge around coordinating many agents at once. --- ## 🧱 Refactor Appendix (append after 🎯 Conclusion) ### 📚 Literature Split Pad - Purpose: Stage Konik CEE units that become per-source Literature notes. - Split level: **H3**. - Include verbatim quotes under 25 words and a [view highlight] link. ### [H1] Orchestration era reshapes software development > [!quote] [Leaving the Agentic Bicycle Era: What comes after Claude Code?](https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code) by [[Keep Websites Weird]] via [[Keep Websites Weird]]. Published 2026-02-04. > “As orchestration tools continue to develop, I think we enter a new, industrial phase of coding with LLMs.” Two lines: Orchestration shifts focus from single agents to fleets coordinated at organizational scale. Useful for framing AI roadmap discussions. [view highlight](https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code#H1) #xref #articleseed ID:rw_[MISSING] ### [H2] Human oversight remains necessary for agents > [!quote] [Leaving the Agentic Bicycle Era: What comes after Claude Code?](https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code) > “I don’t think a no-human-in-the-loop state will ever be functional or desirable for most software use cases.” Two lines: Supports governance models that keep humans accountable for AI‑driven systems. Useful in policy and risk discussions. [view highlight](https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code#H2) #xref ID:rw_[MISSING] --- ### 🔖 Atomic Split Pad (Zettel Candidates) - Purpose: Promote reusable claims into Atomic notes. - Split level: **H4**. - Each item: one idea, present tense, specific, testable. #### [Z1] Agent orchestration becomes primary leverage - In mature AI software teams, orchestration of multiple agents drives more value than single‑agent assistance. - Pointer: Article’s “industrial phase” section. - Links: [[AI-Orchestration]] [[Software-Delivery-At-Scale]] #### [Z2] Human oversight persists in agentic systems - For most production systems, organizations retain humans as accountable supervisors of AI behavior. - Pointer: Article’s argument against fully autonomous agents. - Links: [[AI-Governance]] [[Human-In-The-Loop]] --- ### ✏️ Fleeting Queue (Extract by Selection) - Purpose: Capture quick actions or sparks for Fleeting notes. - Extraction: **Select one line** → “Refactor: Extract selection to new note (content only).” - Keep each line short and self-contained. - [F1] Sketch a diagram of bicycle → automobile → orchestration eras for AI tooling — context/https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code #fleeting #inbox - [F2] Draft a workshop on moving from single‑agent prompts to orchestrated workflows — context/https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code #fleeting #inbox - [F3] Identify one WordPress workflow suitable for multi‑agent orchestration — context/https://keepwebsitesweird.pika.page/posts/the-agentic-bicycle-era-what-comes-after-claude-code #fleeting #inbox --- <!-- deep-read:sections end -->