Human in the loop [01kect62nm9bvy85r8g9fzbam3]

Human in the loop 🔗 **Source:** [Human in the loop](https://jkudish.com/newsletter/006) > [!note]+ Document Notes > ```markdown > > --- > tags: [AI, software-engineering, developer-tools] > author: Joey Kudish > source: jkudish.com > reference: [https://jkudish.com/newsletter/006] > date created: 2026-01-07 12:00 > > --- > > # 🏷️ Title: Human in the loop — #006: From Autocomplete to Implementor >  ## 🧭 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 - What happened: Joey describes shifting from “AI autocomplete” to orchestrating AI coding agents as primary implementors. - Why it matters: Changes the engineer’s role toward architect, reviewer, and meta-prompt designer. - Key stakeholders: Developers, tool vendors, teams exploring AI-assisted workflows. - Risks and tradeoffs: Context quality, code-review complexity, token cost, discipline in documentation. - Bottom line: AI becomes a fast junior implementor; human value concentrates in taste, direction, and feedback loops. ## 📖 Main Content - Joey explains how newer models (e.g., Opus 4.5) reliably read and act on a real codebase, turning AI into an implementor rather than just autocomplete. - He uses custom agents like `/next` that read git history, notes, roadmaps, and issue trackers to propose what to work on. - The Obsidian vault acts as a “second brain,” and AI quality tracks closely with the completeness and clarity of that context. - A learning loop emerges: when AI’s prioritization or implementation is off, he documents corrections and updates prompts/agents, improving future performance. - His role shifts to setting direction, reviewing outputs, explaining corrections, and approving work—like managing a hyper-productive junior developer. - Current gaps: multi-source requirements gathering, fully integrated context across tools, and especially AI code review where you must understand reasoning, not just diffs. - He frames this as a platform shift akin to moving from punch cards to GUIs and notes ongoing experiments with tools like Beads and Clawdbot. ### 🗒️ Notes - AI capabilities crossed a threshold where models can “read my codebase” and push back on overengineering, changing how he spends time. - `/next` agent: - Reads git history, daily notes, roadmap/tasks, Linear and GitHub issues. - Synthesizes a daily “what’s next” suggestion in ~30 seconds instead of 30–40 minutes of manual triage. - Works best when project notes and status markers are rigorously maintained. - Obsidian vault as interface: - Central store for specs, context, daily logs. - Quality of AI’s recommendations is proportional to context hygiene. - Learning loop / meta-prompting: - When recommendations are off, he categorizes errors (big misunderstandings vs. preference tweaks). - Documents corrections in daily notes or `next.md`, or refines the agent. - Over time, both his systems and AI performance improve. - Course-correcting vs babysitting: - He sets direction, lets AI build, then reviews. - If output is good, they ship; if not, he explains why and AI refactors. - Compares AI to a junior dev that’s extremely fast and inexpensive. - Persistent frictions: - Requirements still scattered across Slack, meetings, notes. - Token costs and architecture of “connect everything” still unresolved. - Vault must be continuously updated; automation helps but discipline is critical. - AI code-review frontier: - Need visibility into cross-file interactions, decision rationale, and which prompts shaped which decisions. - Reviewing AI output is more about reconstructing reasoning and ensuring coherence than line-by-line style policing. - Key mindset shift: - AI hasn’t made him obsolete; it lets him stay longer in high-level architectural and design thinking. - Discipline is now in clarity of requirements, architecture taste, intelligent review, rapid course correction, and building robust feedback loops. - Spec writing itself is collaborative with AI, but judgment remains human. ## 📚 References - Joey’s newsletter issue: https://jkudish.com/newsletter/006 - Joey on X/Twitter: https://twitter.com/jkudish - Beads (AI-native issue tracker): https://github.com/beads-xyz (likely home, to verify) - Clawdbot (local AI assistant): https://github.com/clawdbot (or current repo) ## 🗣️ Paraphrase - Paragraph A paraphrase. - Joey realized over the past year that AI went from guessing at completions to understanding real projects well enough that he treats it as an implementor, not a helper. - Paragraph B paraphrase. - He now spends his time coordinating agents, curating context, and reviewing outputs, while AI rapidly executes the implementation details within a structured learning loop. ## 📰 Newsletter AI is no longer just autocomplete for your editor—it’s becoming your fastest junior dev. In this issue, Joey Kudish walks through how he delegates real implementation work to AI agents, powered by a well-organized Obsidian vault and tools like `/next` that auto-prioritize work from git, Linear, and GitHub. If you’re building with WordPress, this framing maps cleanly to plugin and theme workflows: let AI draft code and docs while you focus on architecture, UX, and code review. Pair this with WP-CLI automation, GitHub Actions, and AI-assisted testing to build a humane, scalable dev loop that keeps you in “designer-of-systems” mode instead of “tab-juggling typist.” ## ✅ Action Items #### DevRel - Map Joey’s “AI as junior dev” pattern into live demos and talks for your community (e.g., “From autocomplete to implementor in your stack”). - Produce workshops on building `/next`-style prioritization agents wired into git, issue trackers, and notes. - Improve quickstarts that show how to use AI with existing SDKs and starter repos, emphasizing context hygiene and feedback loops. - Launch content series (blogs, streams) demonstrating AI-assisted code review and meta-prompting with concrete repos. - Survey developers about their biggest “AI workflow paper cuts” to shape documentation and tool improvements. - Align internal teams so DevRel feedback on AI agent use informs product roadmaps and DX tooling. #### OSPO - Clarify policies around AI-generated contributions (attribution, review expectations, and acceptable use of models). - Define license-compliance practices when AI suggests code, including scanning and review cycles. - Integrate security review guidelines specifically for AI-generated patches and refactors. - Track AI-assisted contributions in inventory/SBOMs; document which components were substantially machine-authored. - Offer office hours to help maintainers design safe AI-assisted workflows and clarify legal risks. - Encourage upstream engagement with AI tooling projects that support open-source collaboration. #### Community - Support maintainers with templates for AI-assisted roadmap planning and review checklists. - Create contributor onboarding pathways that explicitly teach how to use AI responsibly (and what not to trust it with). - Standardize sponsor reporting around productivity gains, e.g., “work shifted from manual implementation to AI-augmented review.” - Coordinate cross-project runbooks for incidents involving AI-generated regressions or vulnerabilities. #### WordPress - Core: Explore workflows where AI proposes patches but humans focus on design decisions, regression risk, and long-term maintenance. - Core Performance: Use AI to prototype performance experiments, but formalize human review on metrics and rollout. - Core AI: Set guidelines for local context, code-review visibility, and acceptable automation in core contributions. - **Core Program Team:** Pilot feedback loops where contributor teams log AI successes/failures to refine prompts and policies. - Mobile: Experiment with AI for UI wiring and tests, while designers control UX flows and accessibility standards. - Playground: Offer AI-backed sandboxes that can refactor code or generate examples reproducibly. - Community: Build meetup kits on “AI as your junior dev” with live demos and guardrails. - Training: Publish learning paths for AI-assisted WordPress development, from prompts to code review. - Marketing: Tell practitioner stories where AI freed time for design, accessibility, and performance work. - Support: Use AI to draft replies and KB articles, but enforce human approval and review loops. - Design: Collaborate with AI on variants and microcopy, keeping designers solely responsible for final taste and cohesion. - Documentation: Encourage examples-first docs where AI drafts, and humans refine for clarity and correctness. - Photos, TV, Polyglots, Accessibility, Meta, CLI, Hosting, Tide, Openverse, Themes, Plugins: - Introduce AI for repetitive tasks (summaries, boilerplate, translations), while codifying review and accountability. - Track which AI workflows actually reduce toil vs. introduce new failure modes. #### The WPOCC - Design fellowship tracks exploring AI-assisted maintainership and release engineering. - Pilot microgrants for teams developing open AI-agent workflows for WordPress ecosystems. - Fund documentation sprints focused on “AI in the loop” practices with case studies and templates. - Test matched funding models for tools that concretely reduce contributor burnout via automation. ### FAIR - Encourage AI tooling that runs locally or on user-controlled infra, with transparent model metadata and signatures. - Publish covenants on funding and governance of AI tools in the WordPress ecosystem to prevent capture. - Turn governance artifacts (charters, playbooks, review checklists) into sharable, versioned templates aligned with AI usage. ## 🧪 Hypotheses - H1: Centralized, high-quality project context (vaults, notes, issue links) significantly increases the accuracy and usefulness of AI agents like `/next`. - H2: Developers who treat AI as a junior implementor (with structured review) will ship more features without reducing quality. - H3: AI-generated code requires different review practices than human code, emphasizing reasoning and cross-file coherence. - H4: Iterative documentation of AI errors (meta-prompting) produces compounding improvements in developer productivity. ### 📊 Methodology - H1: Compare teams using a disciplined “second brain” setup versus control teams; measure accuracy of AI task recommendations and time-to-prioritize. - H2: Run longitudinal studies across teams that adopt AI-implementor workflows; track velocity, defect rates, and developer satisfaction. - H3: Design experiments where reviewers assess AI vs human patches with and without access to AI reasoning traces; compare defect detection. - H4: A/B test teams that rigorously log and correct AI failures versus those that do not; measure prompt iterations, cycle time, and rework. ### ❓ Questions - How much centralized context is “enough” before diminishing returns for AI agents? - What new failure modes arise when AI writes most of the code but humans design and review? - Which review practices best catch subtle AI-induced bugs across files and services? - How should teams budget tokens when connecting AI to multiple tools and data sources? ### 🔮 Future Research - Standard formats for exposing agent reasoning and prompt histories for code review. - Best practices for aligning AI prioritization agents with evolving human goals. - Techniques for automatic requirements aggregation from Slack, docs, and meetings with acceptable privacy and cost. - Comparative studies of “AI as pair programmer” vs “AI as implementor” workflows. ### 💡 Implications - Practice: Engineers need to invest in documentation, architecture clarity, and review skills rather than raw typing speed. - Policy: Organizations must define expectations and accountability for AI-generated artifacts. - Security: New review patterns are required to detect systemic issues in AI-written code. - Education: Curricula should include AI collaboration, meta-prompting, and context management. - Funding: Tools that reduce coordination and review overhead may deserve targeted investment. ### 🧠 Learning Styles Assessment - Reading level estimate: Approx. 9th–10th grade (Flesch-Kincaid–style; mostly short, conversational sentences with some technical terms). #### 👀 Visual learners - Present: Mental models (AI as junior dev, second brain), implicit workflows. - Improve: Diagrams of the `/next` data flow, architecture for agents, before/after task triage timelines. #### 🔊 Aural learners - Present: Conversational, newsletter tone that would translate well to audio. - Improve: Short audio summary or podcast-style reading, possibly with commentary on real workflows. #### 🗣️ Verbal learners - Present: Clear analogies (autocomplete vs implementor, junior developer comparison). - Improve: Glossary of terms (meta-prompting, second brain) and more concrete scenario narratives. #### 🧩 Kinesthetic learners - Present: Described workflows that could be replicated. - Improve: Step-by-step guides to building a `/next` agent and setting up an Obsidian vault integration. #### 🧠 Logical learners - Present: Causal chains (better context → better AI; feedback loop → improved system). - Improve: Explicit flowcharts, decision trees for when to trust vs override AI suggestions. #### 🧑‍🤝‍🧑 Social learners - Present: Invitation to share experiences and pain points with AI workflows. - Improve: Discussion prompts, peer group experiments, and case study roundtables. #### 🧘‍♀️ Solitary learners - Present: Reflection-ready framing on how one’s role might change with AI. - Improve: Self-assessment questions about current workflow and potential automation. #### 🌿 Naturalistic learners - Present: Limited explicit ties. - Improve: Analogies to ecosystems (AI agents as species in a niche), lifecycle of tools, and sustainability of attention. ### 📊 Accessibility Assessment #### Screen reader semantics - Present: Simple HTML newsletter layout likely with standard headings. - Improve: Ensure consistent heading hierarchy and descriptive link text. #### Keyboard navigation - Present: Basic web layout should be reachable by keyboard. - Improve: Guarantee visible focus states and skip-to-content link. #### Contrast and readability - Present: Likely acceptable contrast and generous whitespace. - Improve: Confirm 4.5:1 contrast, check body font size and line height for long-form reading. #### Text resizing and reflow - Present: Responsive layout should reflow on mobile. - Improve: Test at 200% zoom; support reduced motion for animations (if any). #### Media and captions - Present: Mostly text; minimal media. - Improve: If screenshots or diagrams are added, supply alt text and captions. #### Forms and interactions - Present: Simple subscription and reply prompts. - Improve: Clear error messages, labeled fields, adequate hit areas. #### Standards reference - Map any gaps against WCAG 2.2 AA, particularly 1.4.x (contrast), 2.1.x (keyboard), and 1.3.x (structure). ### 🌍 DEIB Assessment #### Cultural breadth - Present: Tech-centric, Western SaaS/dev culture framing. - Improve: Include examples from varied regions, job types, and infra constraints. #### Inclusive language - Present: Generally neutral, welcoming; avoids slurs or exclusionary terms. - Improve: Add more plain-language definitions for jargon and avoid platform-specific insider shorthand where possible. #### Neurodiversity support - Present: Chunked sections and clear headings. - Improve: More predictable patterns in callouts, optional summaries per section. #### Representation - Present: Single-author, first-person narrative. - Improve: Highlight stories from diverse developers using similar workflows. #### Psychological safety - Present: Encouraging tone; invites sharing of struggles and friction. - Improve: Explicit norms or links to community guidelines where discussion occurs. ### ✅ Logical Validity #### Strong reasoning - Inductive: Observes personal workflow improvements using AI agents and generalizes cautiously (“for me,” “in my workflow”). - Causal: Argues that better context and documented corrections cause agents to improve; matches known behavior of LLM-based systems. #### Fallacies - Possible survivorship bias: Focus on successful personal setup may underplay teams who struggle even with good context. - Fix: Acknowledge environments where tooling, data, or culture might block similar gains. #### Tone of voice - Conversational, optimistic, lightly skeptical about current gaps, and grounded in personal practice rather than hype. ### 🛡️ DARVO Analysis - Deny: No denial or minimization of harms; acknowledges “paper cuts” and unresolved problems. - Attack: No attacking of skeptics; gently contrasts his experience with online skepticism. - Reverse victim/offender: Does not position himself or AI as victims; frames AI as a tool and himself as an experimenter. ## 🎯 Conclusion - Bottom line: Treat AI as a fast, tireless junior implementor, not just autocomplete. Invest in high-quality context, clear specs, and strong review practices, and use feedback loops to continually upgrade your agents and workflows. - Next steps: Audit your own project context, prototype a `/next`-style agent with your tools, and design a lightweight process for documenting and learning from AI mistakes. ## 🧱 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] 5–10-word present-tense claim > [!quote] [Human in the loop — #006: From Autocomplete to Implementor](https://jkudish.com/newsletter/006) by [[Joey Kudish]] via [[jkudish.com]]. Published 2026-01-06. > “AI stopped being a fancy autocomplete and became something I actually delegate to.” Two lines: context and use. Cite data if relevant. [view highlight](https://jkudish.com/newsletter/006#H1) #xref #articleseed ID:rw_[MISSING] ### [H2] 5–10-word present-tense claim > [!quote] [Human in the loop — #006: From Autocomplete to Implementor](https://jkudish.com/newsletter/006) > “The discipline isn’t in grinding through implementation anymore.” Two lines: context and use. [view highlight](https://jkudish.com/newsletter/006#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] AI acts as a junior implementor - Works when high-quality, centralized context is available and reviewed. - Pointer to article body. - Links: [[AI-Assistants]] [[Software-Development-Workflows]] #### [Z2] Meta-prompting improves agent performance over time - Requires documenting errors and updating prompts/agents iteratively. - Pointer to “Learning Loop” section. - Links: [[Prompt-Engineering]] [[Developer-Productivity]] --- ### ✏️ 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] Prototype a `/next`-style prioritization agent for my own repos — context/https://jkudish.com/newsletter/006 #fleeting #inbox - [F2] Design a checklist for AI-specific code reviews — context/https://jkudish.com/newsletter/006 #fleeting #inbox - [F3] Audit my note-taking and project context for AI readiness — context/https://jkudish.com/newsletter/006 #fleeting #inbox ---