Software Engineering Life

Apr 02, 202612 min read

AI Adoption Journey

My AI Adoption Journey – Mitchell Hashimoto

SUMMARY

  • Mitchell Hashimoto chronicles adopting AI coding agents: ditch chatbots, reproduce work, run end‑day agents, outsource easy tasks, engineer harnesses, and keep one agent running.

IDEAS:

  • Tool adoption passes through inefficiency, adequacy, then workflow-altering discovery requiring persistence despite initial discomfort often.
  • Skepticism can flip quickly after one vivid success like screenshot-to-SwiftUI reproduction performed impressively fast.
  • Chat interfaces encourage copy-paste loops that feel slower than manual work on brownfield projects usually.
  • Coding value emerges when models act as agents using tools, not only conversation and guesses.
  • Minimum viable agent needs file reading, program execution, and HTTP requests in iterative loops.
  • Forcing yourself to redo manual commits with agents builds skill despite excruciating doubled effort.
  • Discovering best practices firsthand creates stronger foundations than merely reading others’ tips and workflows.
  • Splitting work into clear tasks beats attempting one giant “draw the owl” session.
  • Separating planning from execution helps agents handle vague requests without flailing or wandering repeatedly.
  • Giving agents verification mechanisms lets them self-correct, preventing regressions more reliably than human nagging.
  • Efficiency includes knowing when not to use agents because likely failure wastes time quickly.
  • End-of-day agent runs exploit otherwise unproductive time, increasing next-morning momentum and clarity.
  • Deep research agents can survey libraries by license and sentiment, producing multi-page summaries automatically.
  • Parallel experimentation agents can explore vague ideas, revealing unknown unknowns before you start.
  • Triage agents using GitHub CLI can filter issues, generating reports without posting risky responses.
  • Avoiding overnight loops still helps because late-day human fatigue reduces effectiveness and focus.
  • Warm starts matter: precomputed reports reduce ramp-up time and accelerate morning flow.
  • Delegating slam-dunk tasks frees humans to focus on enjoyable, high-leverage thinking work instead.
  • Disabling agent notifications protects deep work; humans should choose interruptions rather than agents.
  • Skill-formation concerns can be mitigated by delegating only some tasks while practicing others manually.
  • Irreversibility threshold appears when you can’t imagine returning after experiencing consistent background assistance.
  • Harness engineering turns recurring agent mistakes into systems fixes, reducing future babysitting needs dramatically.
  • Implicit prompting via AGENTS.md encodes project conventions, preventing repeated wrong commands and APIs.
  • Programmed tools like screenshot scripts and filtered tests provide fast feedback loops for agents.
  • Treat every agent mistake as an opportunity to improve tools so it never recurs again.
  • Always having an agent running reframes idle cycles into continuous parallel progress and iteration.
  • Slow, thoughtful models can take thirty minutes for small changes yet yield higher-quality outputs.
  • Running one agent balances deep manual work with manageable babysitting, avoiding multi-agent chaos.
  • Don’t run agents for vanity; run them when tasks genuinely help and fit workflows.
  • Improving delegation pipelines matters even without AI, because constant high-quality task streams enable productivity.
  • Measured views resist hype; practical utility matters more than ideological stances about permanence.
  • Being willing to feel embarrassed later signals growth; rapid change will date today’s methods.
  • Respecting individual non-use decisions acknowledges ethics, preference, and context beyond pure utility considerations.

INSIGHTS

  • Adoption succeeds when you convert AI from oracle chat into tool-using coworker with feedback loops.
  • The real productivity unlock is parallelism: agents work during your fatigue, meetings, or deep-focus blocks.
  • Mastery comes from deliberate practice: reproduce outcomes twice until you understand agent failure modes.
  • Verification beats persuasion; tests and scripts correct agents faster than repeated conversational corrections.
  • Efficiency includes refusal: knowing when not to delegate prevents negative productivity from predictable agent mistakes.
  • Protect attention like a system resource; disabling notifications preserves deep work and reduces cognitive thrash.
  • Harness engineering is compounding leverage: every fixed mistake permanently improves all future delegated work.
  • Delegation doesn’t inevitably deskill you; keep core craft manual while offloading repetitive slam-dunks selectively.
  • Warm starts change daily throughput: precomputed triage and research shrink ramp-up and decision friction.
  • Sustainable AI use is pragmatic, not performative; only run agents on tasks that truly help.
  • One-agent discipline can outperform multi-agent chaos by matching human oversight bandwidth and focus limits.
  • Rapid model change demands revisiting priors; workflows should be adaptable rather than doctrinal and rigid.

QUOTES:

  • “My experience adopting any meaningful tool is that I’ve necessarily gone through three phases: (1) a period of inefficiency (2) a period of adequacy, then finally (3) a period of workflow and life-altering discovery.” — Mitchell Hashimoto
  • “Adopting a tool feels like work, and I do not want to put in the effort” — Mitchell Hashimoto
  • “This is my journey of how I found value in AI tooling and what I’m trying next with it.” — Mitchell Hashimoto
  • “This blog post was fully written by hand, in my own words.” — Mitchell Hashimoto
  • “Immediately cease trying to perform meaningful work via a chatbot (e.g. ChatGPT, Gemini on the web, etc.).” — Mitchell Hashimoto
  • “Chatbots have real value and are a daily part of my AI workflow, but their utility in coding is highly limited” — Mitchell Hashimoto
  • “my first “oh wow” moment was pasting a screenshot of Zed’s command palette into Gemini” — Mitchell Hashimoto
  • “being truly flabbergasted that it did it very well.” — Mitchell Hashimoto
  • “To find value, you must use an agent.” — Mitchell Hashimoto
  • “An agent is the industry-adopted term for an LLM that can chat and invoke external behavior in a loop” — Mitchell Hashimoto
  • “At a bare minimum, the agent must have the ability to: read files, execute programs, and make HTTP requests.” — Mitchell Hashimoto
  • “I forced myself to reproduce all my manual commits with agentic ones.” — Mitchell Hashimoto
  • “This was excruciating, because it got in the way of simply getting things done.” — Mitchell Hashimoto
  • “Break down sessions into separate clear, actionable tasks. Don’t try to “draw the owl” in one mega session.” — Mitchell Hashimoto
  • “If you give an agent a way to verify its work, it more often than not fixes its own mistakes and prevents regressions.” — Mitchell Hashimoto
  • “block out the last 30 minutes of every day to kick off one or more agents.” — Mitchell Hashimoto
  • “I would NOT allow agents to respond, I just wanted reports the next day” — Mitchell Hashimoto
  • “Very important at this stage: turn off agent desktop notifications.” — Mitchell Hashimoto
  • “Context switching is very expensive.” — Mitchell Hashimoto
  • “I’m making an earnest effort whenever I see an agent do a Bad Thing to prevent it from ever doing that bad thing again.” — Mitchell Hashimoto
  • “having an agent running at all times.” — Mitchell Hashimoto
  • “I’m not [yet?] running multiple agents, and currently don’t really want to.” — Mitchell Hashimoto
  • “I don’t want to run agents for the sake of running agents.” — Mitchell Hashimoto
  • “I’m a software craftsman that just wants to build stuff for the love of the game.” — Mitchell Hashimoto
  • “if you can’t be embarassed about your past self, you’re probably not growing.” — Mitchell Hashimoto
  • “I have no skin in the game here” — Mitchell Hashimoto

HABITS

  • Force yourself through early inefficiency phases to reach discovery rather than quitting prematurely during frustration cycles.
  • Write sensitive posts by hand in your own words to maintain authenticity and personal clarity.
  • Stop using chatbots for meaningful coding tasks; reserve them for lightweight daily utility instead.
  • Use an agent capable of reading files, executing programs, and making HTTP requests repeatedly.
  • Reproduce manual commits with agentic commits to practice, compare quality, and sharpen judgment systematically.
  • Break sessions into clear actionable tasks; avoid giant end-to-end “draw the owl” prompts.
  • Separate planning and execution into different sessions when requests are vague or underspecified initially.
  • Provide agents verification routes like tests or scripts so they self-correct and avoid regressions.
  • Learn when not to use an agent, preventing time loss from predictable failure cases.
  • Block the last thirty minutes daily to kick off agents for overnight-like progress.
  • Run deep research sessions to survey libraries, licenses, activity, sentiment, producing structured summaries quickly.
  • Launch parallel agents exploring vague ideas to surface unknown unknowns before starting implementation.
  • Use GitHub CLI with agents for issue and PR triage, generating reports without replying.
  • Avoid running looping agents all night; keep tasks bounded to manageable completion windows.
  • Shift late-day fatigue time into agent orchestration, preserving human energy for higher-cognition tasks.
  • Filter triage outputs each morning, selecting tasks an agent will almost certainly solve well.
  • Keep one agent running in background while you do deep work on separate tasks.
  • Turn off agent desktop notifications to minimize context switching and protect sustained concentration.
  • Check agent progress only during natural breaks, maintaining human control over interruptions and attention.
  • Engineer harnesses after every mistake so repeated agent errors become impossible in future runs.
  • Maintain an AGENTS.md file of implicit prompting rules derived from observed bad agent behavior.
  • Build programmed tools like screenshot scripts and filtered tests to improve agent feedback speed.
  • Prefer slower thoughtful models for background work when quality matters more than immediate speed.
  • Limit yourself to one agent to match oversight capacity and reduce coordination complexity today.
  • Ask periodically whether an agent could progress something right now, increasing productive parallelism gradually.

FACTS:

  • Most people’s first AI coding attempt happens through a chat interface asking for code generation.
  • Brownfield projects often yield poor chatbot results, creating inefficient copy-paste correction loops for developers.
  • Agents are LLMs that chat and invoke external behaviors repeatedly in a tool-using loop.
  • Minimum agent capabilities include reading files, executing programs, and making HTTP requests programmatically.
  • Mitchell used Gemini to recreate Zed’s command palette in SwiftUI from a screenshot.
  • Ghostty’s macOS command palette is only lightly modified from Gemini’s initial generated SwiftUI output.
  • Claude Code is an agentic coding tool published by Anthropic as an open GitHub project.
  • GitHub CLI gh can be driven by agents to triage issues and pull requests.
  • Agents can complete bounded tasks in under thirty minutes, avoiding overnight autonomous looping sessions.
  • Late working hours correlate with reduced personal efficiency and weaker flow for many knowledge workers.
  • Context switching imposes significant costs, so notification control materially affects deep work performance.
  • Anthropic published research on AI assistance potentially affecting coding skill formation, especially for juniors.
  • Modern coding models like Opus and Codex are trained to bias toward tool use versus chat.
  • AGENTS.md can encode project-specific guidance, reducing repeated wrong commands and API choices.
  • Ghostty maintains a public AGENTS.md example within its GitHub repository for agent instructions.
  • Harness engineering combines implicit prompting and custom tools to improve first-pass correctness for agents.
  • Amp offers a deep mode described as basically GPT-5.2-Codex for slower thoughtful coding.
  • Deep mode may take thirty-plus minutes for small changes yet tends to produce better results.
  • Mitchell reports keeping a background agent running only ten to twenty percent of his workday.
  • Mitchell states he does not work for, invest in, or advise any AI companies.
  • Mitchell’s end-of-day workflow blocks thirty minutes to start agents for next-morning warm starts.
  • Delegating slam-dunk tasks can improve perceived efficiency while preserving manual work for loved tasks.
  • Rapid model innovation forces continual revisiting of priors about what agents can reliably accomplish.
  • Agent triage should avoid autonomous public responses; reports only reduce risks and miscommunication.
  • The blog post “My AI Adoption Journey” was published February 5, 2026 on mitchellh.com.

REFERENCES

ONE-SENTENCE TAKEAWAY

  • Use tool-using agents with verification harnesses, protecting attention, to unlock compounding coding parallelism.

RECOMMENDATIONS

  • Stop attempting serious coding through chatbots; switch to agents with real tool access quickly.
  • Require agents to read files, run programs, and call HTTP endpoints for iterative work.
  • Practice by reproducing every manual commit with an agent until results match your standards.
  • Divide goals into small tasks; avoid mega-prompts that attempt complete systems in one shot.
  • For vague problems, do separate planning sessions before execution so agents follow clearer intent.
  • Add tests, scripts, or checks enabling agents to verify outputs and repair mistakes autonomously.
  • Explicitly decide when not to use an agent, preventing predictable failures and time wastage.
  • Reserve thirty minutes at day’s end to launch agents for research, triage, and exploration.
  • Use agents for deep research summaries across libraries, licenses, activity, and social sentiment metrics.
  • Run parallel agents exploring half-baked ideas to expose unknown unknowns before coding begins.
  • Employ agents with GitHub CLI to triage issues and PRs; forbid them from replying.
  • Keep agent runs bounded; avoid overnight looping unless you can safely constrain behavior tightly.
  • Shift late-day low-energy time toward agent orchestration to preserve best hours for deep work.
  • Start mornings by filtering agent reports, selecting slam-dunk tasks for delegation immediately thereafter.
  • Delegate slam-dunks while you work on high-leverage problems requiring taste, judgment, and creativity.
  • Disable agent desktop notifications; choose interruption moments yourself to reduce context switching overhead.
  • Check agent progress only during natural breaks, maintaining flow and stronger problem-solving throughput.
  • Engineer a harness: convert each recurring mistake into a permanent tool or instruction fix.
  • Maintain AGENTS.md with project conventions so agents stop repeating wrong commands and APIs.
  • Build helper tools like screenshot capture and filtered tests to accelerate feedback for agents.
  • Prefer slower thoughtful models for background tasks where correctness matters more than speed today.
  • Run only one agent initially, matching oversight capacity and preventing coordination complexity and confusion.
  • Aim for always having an agent running, but only when tasks genuinely benefit you.
  • Improve delegation pipelines continuously; even without AI, a steady task stream boosts productivity.
  • Hold a measured view: adopt what works, ignore hype, and respect non-adoption choices.

Graph View

Backlinks