<?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 Michael Murr on Medium]]></title>
        <description><![CDATA[Stories by Michael Murr on Medium]]></description>
        <link>https://medium.com/@michaeltutor?source=rss-7f2ff785a744------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/1*w2MEW3b1HBtYEbUPVOswRQ.png</url>
            <title>Stories by Michael Murr on Medium</title>
            <link>https://medium.com/@michaeltutor?source=rss-7f2ff785a744------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Sat, 21 Nov 2026 04:49:08 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@michaeltutor/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[I Used to Let AI Run Unattended. I Do Not Anymore.]]></title>
            <link>https://medium.com/@michaeltutor/i-used-to-let-ai-run-unattended-i-do-not-anymore-ef92efe942b8?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/ef92efe942b8</guid>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[ai-agents-in-action]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[artificialintelligenceai]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Fri, 25 Sep 2026 15:01:03 GMT</pubDate>
            <atom:updated>2026-09-25T15:01:03.819Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1gbBiLyhtgiF4uymiuf2pA.png" /></figure><p>For most of a year I let long builds run overnight. The logic felt airtight. The model is right the overwhelming majority of the time, I am asleep, the machine is not, and in the morning there would be something to review. I was not reckless about it either. I picked tasks I understood, I read what came back, and I told students it was fine so long as you checked the result.</p><p>Then I looked properly at a loading animation.</p><p>It was a small thing generated during one of those runs. A little car, wheels turning, the sort of graphic you glance at for half a second while a page loads. It ran to completion. Nothing errored, nothing warned, the build was green.</p><p>The brakes were mounted in the wrong place.</p><p>Nobody was harmed by a loading animation. What stopped me was the question sitting behind it: if that shipped without me noticing, what else had? So I sat down and did a line of arithmetic I should have done a year earlier, and I have not started an ungated run since.</p><p>Here is that arithmetic, and the workflow I use in its place.</p><p><strong>In this piece:</strong>What you will build · Step 1: count the decisions · Step 2: run the numbers · Step 3: find the load-bearing decisions · Step 4: gate the front · Step 5: decide what you are checking · What most guides leave out · Wrapping up</p><h3>What you will build</h3><p>Not a script. A gated run: a build you can start and walk away from that stops itself at the few decisions everything else is stacked on, and tells you what to look at when it finishes.</p><p>By the end you will have:</p><ul><li>An honest count of how many decisions your workflow contains</li><li>The real probability that your last unattended run came out clean</li><li>Three checkpoints placed where they do the most work</li><li>A written list of what you are checking, produced before the run rather than after</li></ul><p>Forty minutes the first time, about five per run after that.</p><h3>Step 1: count the decisions, not the prompts</h3><p>The mistake underneath everything else is counting a task as one decision because you typed one instruction.</p><p>Ask what the model actually chose along the way. The file layout. The library. The schema. The error handling. The naming. The test strategy. What to do at every ambiguity your instruction did not cover. In my experience a single paragraph of instruction routinely contains fifteen to twenty implicit decisions.</p><p>You do not have to guess. Ask for the list:</p><p>Have the model enumerate its own decisions before it makes them.</p><pre>Before you write anything, list every decision you will have to make<br>to complete this task. Include the ones I did not specify. For each,<br>say what you would choose by default and what depends on it later.<br>Do not start until I have read the list.</pre><p>Two things happen when you run that. The list is longer than you expected, and some entries are choices you would have made differently. Both are useful before the run and useless after it.</p><h3>Step 2: run the numbers on something you already trust</h3><p>If every decision is independent and each is right nine times out of ten, the odds the whole chain is right is 0.9 raised to the number of decisions. That is the entire model.</p><p>Raise your own per-step accuracy to the power of your own decision count.</p><pre># Odds an entire chain is correct, at a given per-step accuracy.<br>for accuracy, steps in ((0.90, 5), (0.90, 10), (0.90, 20), (0.90, 50),<br>                        (0.95, 20), (0.99, 50)):<br>    print(f&quot;{accuracy:.0%} x {steps:2d} steps -&gt; {accuracy ** steps:.1%}&quot;)</pre><p>What it prints is the part that ended my overnight habit.</p><pre>90% x  5 steps -&gt; 59.0%<br>90% x 10 steps -&gt; 34.9%<br>90% x 20 steps -&gt; 12.2%<br>90% x 50 steps -&gt; 0.5%<br>95% x 20 steps -&gt; 35.8%<br>99% x 50 steps -&gt; 60.5%</pre><p>Ten decisions at ninety percent is about thirty five percent. Roughly one run in three comes out clean, and it takes around twenty two decisions to fall under ten, so the honest number is neither the ninety people assume nor the catastrophe they jump to when they overcorrect.</p><p>Look at the last line. Even at ninety nine percent per step, fifty steps is a coin flip. No per-step accuracy makes an arbitrarily long chain safe, because that is multiplication, not a criticism of any model.</p><h3>Step 3: find the load-bearing decisions</h3><p>This is the step that takes actual thought, and it is where the technique lives.</p><p>You do not need a gate on every decision. You need gates on the decisions everything downstream depends on. Verify one of those and confirm it is right, and that term stops being 0.9 and becomes roughly 1, so the chain restarts from there.</p><p>One verified checkpoint splits one long chain into two short ones.</p><pre># A 20-step chain, ungated, versus the same chain with a verified midpoint.<br>print(f&quot;no gate:  {0.9 ** 20:.1%}&quot;)<br>print(f&quot;each half: {0.9 ** 10:.1%}&quot;)</pre><p>One twelve percent run becomes two thirty five percent runs with a repair step between them. Three of these are usually enough. Here is where they belong.</p><h3>The schema and the data model</h3><p>Everything afterwards assumes this shape. A wrong relationship, or a wrong assumption about what is nullable, propagates into every query, form and test built on top of it. Almost always checkpoint one.</p><h3>The core abstraction</h3><p>The module or interface other code calls. Getting this wrong breaks nothing immediately, which is exactly what makes it expensive. It breaks slowly, in twelve places, a week later.</p><h3>The boundary you cannot cheaply reverse</h3><p>A public endpoint, a stored format, an external contract, a migration. Cheap to gate now, expensive to revisit.</p><p>The test for whether something belongs here: if this decision were wrong, how many later ones would also be wrong? If the answer is one or two, leave it alone and let the model run.</p><h3>Step 4: gate the front, not the end</h3><p>Most people put their attention at the end, where the output appears. The leverage is at the front, where the assumptions are. A checkpoint at step two protects the eighteen decisions after it. The same checkpoint at step eighteen protects two.</p><p>The tools ship a gate for exactly this and most people turn it off in week one. Claude Code’s <a href="https://code.claude.com/docs/en/permissions">permission modes</a> include a plan mode where “Claude reads files and runs read-only shell commands to explore but doesn’t edit your source files”.</p><p>Explore and plan before anything is allowed to write.</p><pre>claude --permission-mode plan</pre><pre>&gt; Read the codebase and propose the schema and the module boundaries.<br>&gt; Do not create or edit any files yet.</pre><p>That is a gate placed before the chain starts rather than an apology after it ends. It costs a few minutes and it protects everything.</p><h3>Step 5: decide what you are checking before you start</h3><p>Here is the failure mode I walked into after first seeing that table, and I have watched several people repeat it. They gate everything. Every step gets a prompt, the run takes four times as long, and after twenty clicks of approve they are rubber stamping without reading.</p><p>A gate nobody evaluates is worse than no gate, because it produces the paperwork of verification and none of the substance. The test is simple: if you cannot say what you would be looking for when you reach a checkpoint, it is not a gate, it is a speed bump. So write the question down first.</p><p>Commit the checks to a file before the run, not after.</p><pre>cat &gt; RUN-CHECKS.md &lt;&lt;&#39;EOF&#39;<br>1. Schema: are the three relationships right, and is anything nullable<br>   that should not be?<br>2. Module boundary: does anything outside the core reach into it?<br>3. Output: does the generated component render correctly at 200% zoom?<br>EOF</pre><p>When it finishes, verify against the data rather than the code. The instinct is to open the file that probably caused it and read until you spot the mistake. That feels productive and is close to useless, because you are asking your own assumptions to audit themselves.</p><p>Ask what actually got written, not what the code says should have been.</p><pre>-- Did the run write what it claims? Check the rows, not the source.<br>SELECT status, COUNT(*), MIN(created_at), MAX(created_at)<br>FROM sessions<br>GROUP BY status<br>ORDER BY 2 DESC;</pre><p>On a Pomodoro timer of mine, a project about as simple as a real one gets, several reported bugs turned out to be correct behaviour I had misunderstood. I would never have found that by rereading the code.</p><h3>What most guides leave out</h3><p>Everything above is mechanics, and mechanics are the easy part. What actually changed how I work is a distinction nobody put in front of me for years.</p><blockquote><em>It ran to completion. No errors, no warnings, no failed build. The car had its brakes mounted in the wrong place.</em></blockquote><p>Automated checks catch the failures you predicted. Green tests and a quiet linter confirm the code satisfies the rules you thought to write down in advance. None of them has an opinion about whether the brakes belong on that part of the car.</p><p>Compounding failures are, almost by definition, the ones nobody predicted, because anything predicted would already have a gate on it. The numbers say roughly two runs in three contain something wrong. The silence says you will not be told which two.</p><p>The second thing cuts the other way, and it is cheaper than everything above. Per-step accuracy is not a fixed property of the model. It is a property of the model plus what you gave it, which is the whole argument for <a href="https://aitutorcode.com/blog/claude-code-skills">loading your skills before you build anything</a>. Moving ninety to ninety five by fixing the context buys what buying a better model buys, and usually costs nothing.</p><p>Anthropic’s own <a href="https://www.anthropic.com/engineering/building-effective-agents">engineering guidance on building agents</a> lands in the same place from the other direction, noting that “the autonomous nature of agents means higher costs, and the potential for compounding errors” and that agents “can then pause for human feedback at checkpoints or when encountering blockers”. The arithmetic is that sentence with numbers attached.</p><p><em>Reviewing an unattended run is a different activity from reviewing your own work.</em> Writing something yourself, you carry a mental list of the parts you were unsure about. After an unattended run that list does not exist, so you have to build it deliberately.</p><h3>Wrapping up</h3><p>I still let things run without watching them. I have not become the person who approves every step, and I would not recommend becoming one. What changed is that I know roughly what I am gambling before I start, and there are three places in every run where the chain gets to restart.</p><p>Across something north of 3,000 hours of one to one sessions, this is the change that has moved the most work for the least effort. Not more caution. Better placed caution.</p><p>If you take one thing from this, do the arithmetic on a workflow you already run unattended. Not a hypothetical one. The one you set going last week and did not watch.</p><p>Worth reading next:</p><ul><li><a href="https://aitutorcode.com/blog/compounding-accuracy">Your AI is right 90% of the time, your build is not</a>, the long version with the full probability table</li><li><a href="https://aitutorcode.com/blog/claude-code-handoff-file">A handoff file the next session can read</a>, which makes a checkpoint you passed on Tuesday still a checkpoint on Thursday</li><li><a href="https://aitutorcode.com/blog/is-claude-code-safe">Is Claude Code safe to use</a>, on what the tool gates and what it quietly does not</li></ul><p>If you would rather work out where your own gates belong with someone watching the screen, bring the workflow you trust least to a free <a href="https://aitutorcode.com/contact">Discovery Call</a> and we will count the decisions together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ef92efe942b8" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Is Your AI Coding Bill So Unpredictable?]]></title>
            <link>https://medium.com/@michaeltutor/why-is-your-ai-coding-bill-so-unpredictable-69afaf9aecc2?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/69afaf9aecc2</guid>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[vibe-coding]]></category>
            <category><![CDATA[llm]]></category>
            <category><![CDATA[ai]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Fri, 18 Sep 2026 16:31:01 GMT</pubDate>
            <atom:updated>2026-09-18T16:31:01.329Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*aQFg1ehjPwZc9EQ6Ef-bNw.png" /></figure><p>Two vendors, two pricing pages, and neither one will tell you what next month costs. That is not a complaint about transparency. Both pages are accurate, both are published in good faith, and I have no reason to think either company is hiding anything. The problem is narrower and more annoying than a cover-up: the pages answer a question almost nobody is asking.</p><p>A published rate is a price per token. Your bill is decided by how many tokens a task turns out to need, and that number is a property of the task, not of the rate card. The two things are related, but only loosely, and the gap between them is where every billing surprise I have watched land on a working professional this year has come from.</p><p>Some are small. Somebody expected forty dollars and paid sixty. Some are not. I once turned a fifteen word request into a locked account and a wasted afternoon, in front of a student, without doing anything unusual.</p><p>What follows is six of those gaps, drawn from a month of session notes, one controlled measurement across five models, and both vendors’ own documentation as it stood in September 2026.</p><ul><li>The rate card that does not predict your bill</li><li>The winner that loses the next race</li><li>The fifteen words that cost four hours</li><li>The number that neither vendor will print</li><li>The allowance that your phone quietly spends</li><li>The week of your own data that settles it</li></ul><h3>The rate card that does not predict your bill</h3><p>Start with the thing that looks most solid and is least useful.</p><p>As of September 2026, Anthropic publishes per million tokens: Opus 5 at five dollars in and twenty five out, Sonnet 5 at two and ten, Haiku 4.5 at one and five. Read that list and one conclusion jumps out, which is that Opus costs several times what Sonnet costs. Reasonable conclusion. Wrong unit.</p><p>I ran a controlled test with a student. One prompt, a falling sand simulation with eight interacting materials, one shot with no follow ups, five models, each asked to report its own tokens, cost and wall clock time. Opus 5 produced roughly eight million tokens and about ten dollars in twenty two minutes. Opus 4.8, on identical published rates, produced seventy eight thousand tokens and about seventy three cents in seven minutes.</p><blockquote><em>“Opus 5 and Opus 4.8 have identical published rates. On this task one cost roughly fourteen times the other, because it generated roughly a hundred times the tokens.”</em></blockquote><p>Two of us looked at the finished simulations independently and could not tell them apart.</p><p>Part of the mechanism is documented. Anthropic notes that Claude 4.7 and later use a newer tokenizer producing about thirty percent more tokens for the same text, and newer models lean on extended thinking by default, which bills as output. A model can be identically priced, genuinely better, and still cost several times more on the same job.</p><h3>The winner that loses the next race</h3><p>Here is where I have to argue against my own measurement, because leaving it unqualified would be the more comfortable option and the less honest one.</p><p>That falling sand result is one task, and I now think it is the outlier. Aggregate benchmarking from Artificial Analysis puts weighted cost per task at roughly $2.75 for Fable 5 against $2.03 for Opus 5, which is the opposite ranking to mine. A harder test I ran the same month, a 2D physics engine built from byte identical specification files, put Opus clearly ahead. And months of daily use point the same way.</p><blockquote><em>“The ranking inverted between two tests run by the same person, in the same month, using the same method, and the only thing that changed was the shape of the task.”</em></blockquote><p>That is a more useful finding than a leaderboard, because it survives contact with your situation. A visual simulation rewarded one model. A rigorous engine build rewarded another. Neither generalises to your work, and neither does anyone else’s, including the confident comparison you read last week. A cost ranking has a shelf life measured in task types, not in months.</p><h3>The fifteen words that cost four hours</h3><p>This is the expensive one, and it is the gap I see most often in sessions.</p><p>People budget for prompt length. They worry about pasting a long file or letting a conversation run on. Those costs are real and they are gradual. The thing that actually empties an allowance is one short instruction that fans out into parallel agents, each carrying its own context window.</p><blockquote><em>“Running several sessions or subagents at once multiplies token usage.”</em></blockquote><p>That is <a href="https://code.claude.com/docs/en/agents">Anthropic’s own documentation</a>, stated plainly. On the costs page they go further, noting that agent teams use approximately seven times more tokens than standard sessions when teammates run in plan mode, because each teammate maintains its own context and runs as a separate instance.</p><p>I did this to myself, unplanned, in front of a student. I asked for a thorough review of a whole project, on the most expensive model, with everything loaded. It spawned roughly ten subagents, one of which consumed three hundred thousand tokens by itself. I went from one percent usage to one hundred percent in about twelve minutes, was locked out for four hours, and the review never finished.</p><p>The instruction was fifteen words. The bill had nothing to do with those fifteen words and everything to do with how many contexts they opened.</p><p>The tell, once you watch for it, is the moment output stops being one stream and becomes a list of workers starting up. You have a few seconds to press Escape, and Escape is nearly always cheaper than letting it run.</p><h3>The number that neither vendor will print</h3><p>Every week somebody asks me how many hours they get for their money. There is no published answer, and it took me an embarrassingly long time to accept that this is deliberate rather than something I had failed to find.</p><p>What makes it interesting is that the two vendors are opaque in opposite directions.</p><p>What you want to knowAnthropic publishesOpenAI publishesMessages per windowNothing at allPer model rangesPlus or Pro tier figuresRelative multiples only, 5x and 20xSol 10 to 100, Terra 25 to 200, Luna 250 to 2,000WindowFive hours, plus a weekly windowRolling five hoursWhat your task will costNothingNothing</p><blockquote><em>“Any article that tells you Pro gives you a specific number of messages or hours is publishing a third-party estimate, not a documented figure.”</em></blockquote><p>Anthropic describes Max tiers as five times and twenty times a base allowance that is itself never stated. OpenAI does print numbers for Codex CLI, which looks more helpful until you read the spread. Between the flagship model and the cheapest one, the message allowance on the same plan varies by more than an order of magnitude. A range that wide is honest, and it is also not a budget.</p><p>So both vendors leave you in the same position by different routes. One declines to give you a number. The other gives you a number so wide that your model choice, not your plan, decides your usable volume.</p><h3>The allowance that your phone quietly spends</h3><p>This one genuinely surprises people, and it is the cheapest thing on this list to fix.</p><p>On Anthropic’s side the allowance is shared. Claude Code, the Claude apps and Cowork all draw from one pool, and the company states it directly for seat based plans. A morning of chat on your phone reduces what is left for the terminal that afternoon.</p><blockquote><em>“The allowance is not per tool. It is per account, and most people are spending it in three places without noticing.”</em></blockquote><p>Nobody budgets for this because nothing in the interface suggests the two activities are connected. The conversation you had on the train has a cost that lands later, in a different application, when you are trying to work.</p><p>The only published dollar figures worth anything for planning are enterprise averages: around thirteen dollars per developer per active day, and roughly a hundred and fifty to two hundred and fifty per month. Useful as a sanity check. Useless as a ceiling.</p><h3>The week of your own data that settles it</h3><p>After 3,000 hours of one to one sessions with working professionals, the advice I give on this has narrowed to something almost boring, which is usually a sign it is right.</p><p>Stop looking for the published limit. There is not one, and the hours you spend hunting for it are worth more than the answer would be.</p><blockquote><em>“A pricing page is a rate, not a bill. A benchmark is an average of tasks that are not yours. And one test, even a careful one you ran yourself, is one sample.”</em></blockquote><p>Run a normal week and record it. Check usage daily rather than at month end, because the point is to learn the shape of your own consumption, not to audit it afterwards. That week will tell you more than every benchmark article combined, this one included.</p><p>Three habits do most of the work. Scope anything containing the words thorough, full, entire, or across the codebase, and name a directory before you run it.</p><pre>Review src/auth/ only. Report findings as a numbered list.<br>Do not open files outside that directory.</pre><p>Check usage immediately after any task that spawned agents, while you can still connect the number to the instruction that caused it. And set a spend cap on the day you enable overage billing, not the day you discover you needed one, because the moment you cross an allowance you stop being on a subscription and start paying per token.</p><p><em>The unpredictability is not going away, because it was never really about price.</em> A natural language instruction has no obvious relationship to the amount of computation it triggers, and we are all still learning to estimate that by eye. I got it wrong with fifteen words.</p><p>I wrote up the full Claude Code breakdown in <a href="https://aitutorcode.com/blog/claude-code-pricing">five things Claude Code pricing does not tell you</a>, and the OpenAI side in <a href="https://aitutorcode.com/blog/codex-cli">what Codex CLI actually is and when to use it</a>. For why the cheap tier disappeared in the first place, that is <a href="https://aitutorcode.com/blog/why-20-dollar-ai-coding-era-is-over">the end of the twenty dollar era</a>.</p><p>If your bill keeps moving and you cannot work out which of your habits is doing it, bring a week of your own usage to a free <a href="https://aitutorcode.com/contact">Discovery Call</a> and we will find it together.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=69afaf9aecc2" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Does Your AI Keep Writing Outdated Code?]]></title>
            <link>https://medium.com/@michaeltutor/why-does-your-ai-keep-writing-outdated-code-f923c16e2e7f?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/f923c16e2e7f</guid>
            <category><![CDATA[llm-applications]]></category>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[software-engineering-job]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[artificialintelligenceai]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Fri, 11 Sep 2026 17:36:01 GMT</pubDate>
            <atom:updated>2026-09-11T17:36:01.367Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oKfxvtrdJy1YsBGRJFvK3g.png" /></figure><p>He had been building the same site for five sessions. It broke when you zoomed. A scroll effect he had asked for three times never landed, and each session we patched something and moved on. In session six I stopped patching and looked at the setup instead. The project had nothing loaded. No skills, no plugins, nothing telling the model anything about how this kind of work is done in 2026. It had been writing from memory the whole time, and nothing had ever said so.</p><h3>The failure mode that never announces itself</h3><p>My phrase for that, which he has repeated back to me several times since, is working in the dark.</p><p>It is worth being precise about what went wrong, because it is not what people expect. Nothing crashed. There was no error to search for and no warning to dismiss.</p><blockquote><em>“Nothing in either project errored. Nothing warned. The output looked finished, and the only way either of them found out was by comparing it against something built properly.”</em></blockquote><p>That is the whole problem in two sentences. A build that errors is telling you the truth. A build that completes is only telling you it completed.</p><p>He is not careless, and he is not a beginner. He is a working professional who had shipped a live site. In roughly 3,000 hours of one-to-one teaching, the failures that cost people the most time have almost never been the loud ones.</p><blockquote><em>“A failure you cannot see is not a failure you will get around to fixing.”</em></blockquote><p>So when someone tells me their AI keeps writing outdated code, my first question is no longer about the model or the prompt. It is what the model could see when it wrote.</p><h3>Two kinds of memory, and most projects have neither</h3><p>There are exactly two ways to give a coding agent standing knowledge, and the difference between them is the thing almost nobody gets told.</p><p>A skill is on demand. It is a markdown file the tool reads only when your request calls for it, which means a three hundred line accessibility checklist costs you nothing until the moment it is writing markup.</p><p>An instructions file is always on. It loads at the start of every session whether or not it is relevant, which is why it has to stay short.</p><p>That single distinction sorts every piece of guidance you will ever want to give. Standing facts about the project go in the always-on file. Long reference material goes in a skill. I wrote the full mechanics of <a href="https://aitutorcode.com/blog/claude-code-skills">loading skills before you build anything</a> separately, because the setup takes about fifteen minutes and most people have never done it once.</p><p>Here is the part that surprises even careful people. The always-on file is not a settings panel. Anthropic is unusually direct about this in <a href="https://code.claude.com/docs/en/memory">their own documentation</a>:</p><blockquote><em>“CLAUDE.md content is delivered as a user message after the system prompt, not as part of the system prompt itself. Claude reads it and tries to follow it, but there’s no guarantee of strict compliance, especially for vague or conflicting instructions.”</em></blockquote><p>Read that twice if you write these files. It reframes the whole exercise. Vague rules get vague compliance. Two rules that contradict each other get resolved arbitrarily, because the model may simply pick one.</p><p>Which means a rule that absolutely must hold every time does not belong in the file at all. It belongs in a hook, which runs as a shell command at a fixed point regardless of what the model decides. <em>Context shapes behaviour. It does not enforce it.</em></p><p>There is a second-order version of this failure that catches the people who did everything right. You can install the skills, verify they are loaded, and still have them never fire.</p><p>The tool only reads each skill name and description at startup, not the body. That listing has a character budget, and when you install enough to overflow it the descriptions get shortened, starting with the ones you invoke least. Shortened descriptions lose the exact words the model was matching on.</p><p>So a description written like a title is a skill that sits there costing you nothing and doing nothing. “Accessibility checks” will not fire. “Use when writing or reviewing markup, components, or anything user facing” will. You are writing matching conditions, not a label, and more installed skills is not the same as more loaded knowledge.</p><h3>The advice that moved in July, and almost nobody noticed</h3><p>If you last read anything about instructions files in 2025, your mental model is out of date, and it is out of date in the opposite direction to what you would guess.</p><p>On 24 July 2026, alongside the Opus 5 launch, Anthropic published <a href="https://claude.com/blog/the-new-rules-of-context-engineering-for-claude-5-generation-models">new guidance on context engineering</a> and disclosed something about their own work that I have not seen widely repeated:</p><blockquote><em>“We removed over 80% of Claude Code’s system prompt for models like Claude Opus 5 and Claude Fable 5 with no measurable loss on our coding evaluations.”</em></blockquote><p>The team with the most to lose from a weaker prompt deleted four fifths of it, and the evaluations did not move. That is not a small tuning result. It is the people who build the tool telling you that the thing you were adding was costing you something and buying you nothing.</p><p>Their advice for your file follows the same logic: keep it lightweight, describe briefly what the repo is for, and spend most of the tokens on the gotchas inside the codebase.</p><p>So the instinct nearly everyone has, that a longer instructions file produces a better behaved model, is backwards. Past a certain length the file stops being instructions and becomes noise, and the documented failure mode is that the important rules get lost among the unimportant ones. My own file for this blog runs about thirty lines and does more for output quality than any clever prompt I could write in the moment. The full breakdown of <a href="https://aitutorcode.com/blog/what-is-claude-md-file">what actually belongs in one</a> is worth twenty minutes if you have never audited yours.</p><h3>What I check now, before anything else</h3><p>The audit takes about ten seconds and I have started running it at the top of first sessions, before we discuss anything the student came to discuss.</p><pre>ls .claude/skills/*/SKILL.md<br>ls ~/.claude/skills/*/SKILL.md</pre><p>If both come back empty, we have found the session’s real topic. That is exactly what his project returned in session six.</p><p>One habit goes with it, and it generalises far beyond this tool. Verify with the tool, not with the model. Asking the assistant whether your skills loaded gets you a confident answer assembled from context rather than a reading of what is actually attached. Ask the thing that knows. It takes the same ten seconds and it is the difference between believing your setup works and knowing it does.</p><p>I want to be careful not to oversell this as a universal explanation. Plenty of AI frustration is genuinely about the model, or the prompt, or a task that was never realistic. But an enormous share of what gets blamed on the model turns out to be <a href="https://aitutorcode.com/blog/setup-problems-that-stall-ai-beginners">setup that nobody ever configured</a>, and setup is cheap to fix once you know to look.</p><p>There is a second half to this that costs people more than the first. Agreeing a rule with the model in conversation feels like setting it. It is not.</p><blockquote><em>“A constraint that lives only in the conversation does nothing.”</em></blockquote><p>I have watched a student agree two hard constraints out loud in one session, neither of them written down, and watched the model break one of them in the next session. When a long conversation compacts to free up room, the instructions that live only in the chat are among the first things that do not survive. The file on disk gets re-read. The thing you said does not.</p><p><em>Say it, then write it down.</em> That is the entire habit, and it takes longer to describe than to do.</p><p>His fix, in the end, was four installs, a restart, and one prompt he wrote himself. The site started improving in the same session, after five sessions of not improving. What stayed with me was not the fix. It was that he had spent five weeks assuming the ceiling he kept hitting was his own.</p><p>If you want someone watching your screen while you work out what your setup is actually missing, that is what my sessions are. <a href="https://aitutorcode.com/contact">Book a free Discovery Call</a> and bring the project that is annoying you.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=f923c16e2e7f" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[What Can AI Actually Set Up for You, and What Still Needs You?]]></title>
            <link>https://medium.com/@michaeltutor/https-aitutorcode-com-blog-can-claude-set-up-your-jira-service-desk-a20404ed93fc?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/a20404ed93fc</guid>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[openai-codex]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Fri, 28 Aug 2026 13:21:01 GMT</pubDate>
            <atom:updated>2026-08-28T13:21:01.209Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*6AMYq3QuHS1uliyjtIDAAg.png" /></figure><p>Every engagement I ran last month eventually hit the same wall, in a different tool each time, and always in the same place. Someone asks the AI to connect their systems together, and it says no.</p><p>That moment is where most people conclude the tool is overhated or oversold, and give up on the project. It is actually the most useful moment in the whole engagement, because the boundary is completely predictable once you have seen it, and there is a real path on the other side of it.</p><p>This walkthrough is the map I now give people before they start, so they find the line in hour one instead of week four.</p><p><strong>In this walkthrough:</strong></p><ul><li>What you will map</li><li>Step 1: Write down the outcome, not the tool</li><li>Step 2: Split every task into produce or change</li><li>Step 3: Test the hardest step first</li><li>Step 4: Get the artifact for the produce column</li><li>Step 5: Hand the change column to whoever has the access</li><li>What the other guides leave out</li><li>Wrapping up</li></ul><h3>What you will map</h3><p>A two-column split of your actual project, showing which parts an AI can deliver and which parts require a human with permissions. When you finish you will have:</p><ul><li>A list of concrete artifacts you can ask for today</li><li>A shorter list of clicks that only a person with access can perform</li><li>An honest timeline instead of a hopeful one</li><li>The hardest step tested before you build anything around it</li></ul><p>It takes about thirty minutes and it routinely saves a month.</p><h3>Step 1: Write down the outcome, not the tool</h3><p>Start with what you want to be true when this is finished, in one sentence, with no product names in it.</p><p>One of my students wanted twelve separate project spaces visible in one place, so she could see every ticket across every programme and know what was current. That is the outcome. “Connect Jira to Claude” is not an outcome, it is a guess at a method.</p><pre>Bad:  &quot;Connect my project tool to the AI.&quot;<br>Good: &quot;See every open ticket across twelve programmes<br>       in one prioritised view, updated daily.&quot;</pre><p>The reason this matters is that the outcome usually has three or four possible routes, and the one you guessed is often the only one that is blocked.</p><h3>Step 2: Split every task into produce or change</h3><p>Take the outcome and break it into the actual jobs underneath. Then sort each one into one of two columns.</p><p><strong>Produce</strong> means creating content, text, code, a design, an analysis. Nothing in the world changes state.</p><p><strong>Change</strong> means altering a system that has its own permissions: creating something, configuring something, granting access, publishing.</p><pre>PRODUCE                          CHANGE<br>write the cross-project query    create and save the filter<br>design the board layout          build the board<br>draft the documentation          set the permissions<br>summarise across spaces          configure the project<br>generate the content             publish it</pre><p>That line held in all four engagements I ran, across completely different tools.</p><h3>Step 3: Test the hardest step first</h3><p>This is the step everyone skips and it is the one that decides whether your plan is real.</p><p>Pick the single item in your Change column that you are least sure about. Not the first one. The scariest one. Then test only that, before building anything around it.</p><pre>Ask the tool directly:</pre><pre>&quot;I want to [specific change] in [system].<br> Can you perform that yourself, or does a person<br> with admin access have to do it? Be specific about<br> which parts you can and cannot do.&quot;</pre><p>You will get an honest answer, and it takes two minutes. My student asked this in week four rather than week one, and the four weeks in between were spent building toward something that was never going to work the way she assumed.</p><h3>Step 4: Get the artifact for the produce column</h3><p>Everything in the Produce column is available to you right now, and this is the half people underestimate because they are still annoyed about the other half.</p><p>For the cross-project view, the artifact is a query. Ask for it explicitly:</p><pre>&quot;Write the query that pulls every open issue across<br> these twelve projects, sorted by priority. Explain<br> what each clause does so I can adjust it myself.&quot;</pre><p>That query took minutes. It is also most of what she actually wanted, because the thing she cared about was seeing everything in one place, not the mechanism.</p><p>Four of the five rows in that table above are largely automatable. The one that is not takes the least time once you have the artifacts from the other four.</p><p>Ask for the rest of the column the same way, one artifact at a time:</p><pre>&quot;Draft the documentation page for this view: what it<br> shows, who it is for, and how to change the filter.<br> Plain language, no jargon, ready to paste.&quot;</pre><p>The pattern is always the same. Name the artifact, name the audience, say what “finished” looks like. Vague requests are where people conclude the tool is not useful, when what actually happened is that nobody told it what done meant.</p><p>Things worth asking for in the Produce column, in rough order of time saved:</p><ul><li>The query or filter logic, with each clause explained</li><li>The layout or structure spec, written so someone else can build it</li><li>The documentation, drafted from what already exists in your systems</li><li>A summary across sources you would otherwise read manually</li><li>The content itself, in your organisation’s voice, from a context file</li></ul><h3>Step 5: Hand the change column to whoever has the access</h3><p>Now you have a spec rather than a request, which is a completely different conversation to have with an administrator.</p><p>Instead of “can someone set up a board for me,” you arrive with the query written, the layout designed, and the permissions listed. The person with access does ten minutes of clicking rather than an hour of interpretation.</p><p>If that person is you, even better. You now know exactly what to click and why.</p><h3>What the other guides leave out</h3><p>Three things, none of them technical, all of them the reason projects actually fail.</p><h3>The boundary is not a bug and it is not going away</h3><p>Connecting projects into a shared view is configuration: boards, filters, permissions, project settings. It lives behind an access model that exists precisely to stop things outside the system from changing it.</p><p>An AI agent reaching in from outside is correctly unable to do that. This is not a capability gap that a better model closes next year, and you would be genuinely alarmed if it were otherwise. Treating it as a temporary limitation is why people keep waiting for a release that solves it.</p><p>It is also why the connection method matters less than people think. Whether you use an official connector or <a href="https://modelcontextprotocol.io/">a locally run one built on an open protocol</a>, the permissions model on the far side is unchanged. Better plumbing does not grant you access you did not have.</p><h3>The person who cannot say no will cost you a month</h3><p>When my student asked whether she could build things and push them out to her company systems, I said yes before I had verified it. That turned out to be exactly the uncertain part, and I had to walk it back later.</p><p>The honest sentence is “that is the goal, and here is what we need to confirm before I promise it happens automatically.” Saying the cheerful version first and qualifying afterwards is worse than saying nothing, because by then someone has built a plan on it.</p><p>If you are working with anyone on this, including me, listen for whether they verify before they reassure.</p><h3>The reframe is where the value actually is</h3><p>“The tool cannot do it” is a dead end. “Here is what it produces, here is what a human configures, and here is who does which part” is a plan, and in every case I have run it also delivers most of what the person originally wanted.</p><p>The difference between those two sentences is not optimism. It is having done the split.</p><h3>Wrapping up</h3><p>Thirty minutes of sorting your goal into Produce and Change tells you whether your plan is realistic, and usually reveals a faster route to the thing you actually wanted.</p><p>Do it before you commit budget, before you promise a timeline, and before you pick a tool. The four engagements I ran last month all hit this boundary. The ones that went well hit it in hour one.</p><p>Further reading:</p><ul><li><a href="https://aitutorcode.com/blog/can-claude-set-up-your-jira-service-desk">What AI can and cannot set up in your systems</a>, the longer version of this split with a worked example</li><li><a href="https://aitutorcode.com/blog/claude-code-handoff-file">Building a handoff file</a>, for keeping the artifacts alive across sessions once the project runs longer than one sitting</li></ul><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=a20404ed93fc" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Does Your AI Setup Break Every Time You Come Back?]]></title>
            <link>https://medium.com/@michaeltutor/why-does-your-ai-setup-break-every-time-you-come-back-0196bdd64119?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/0196bdd64119</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[claude]]></category>
            <category><![CDATA[cursor]]></category>
            <category><![CDATA[google-gemini]]></category>
            <category><![CDATA[openai-codex]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Fri, 21 Aug 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-08-21T13:01:02.850Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W8QgUITgiFv7oPQF0AfzJQ.png" /></figure><p>Forty minutes into a session last month, a connection my student had spent three weeks getting working simply broke. Two enterprise systems, both authenticated, both live the week before. One returned an error, the other timed out.</p><p>We had spent the first twenty minutes of that same session writing a file about how the connection was built. I had no idea we were about to need it.</p><h3>The technique that paid for itself inside the hour</h3><p>The file was not documentation in the usual sense. It was a report the tool wrote about its own work, aimed at a future version of itself with no memory of the conversation.</p><p>The instruction was close to this:</p><blockquote><em>Write a detailed file documenting how this project is currently configured. Every service connected and how, the exact commands used, where credentials live (the file path only, never the values), and anything that surprised you or needed a workaround. Write it for a future session with no memory of this conversation.</em></blockquote><p>That last sentence is the part that changes the output. Without it you get a summary. With it you get instructions.</p><p>When the connection broke, I did not start debugging. I pointed the tool at the file it had written twenty minutes earlier and asked it to work out what had changed.</p><p>It read its own notes, pulled its own debug logs, and came back with two separate problems rather than one: an expired token on the first service, and a package update that had arrived with an install on the second.</p><p>Two causes, correctly separated, from a system diagnosing itself. Then it walked her through fixing both while I mostly watched. The whole recovery took less time than the documentation had, which is not a coincidence so much as the entire argument for writing it.</p><p>I want to be precise about why this worked, because it is not that the tool is clever. It is that it had a written record of its own prior decisions. Strip that away and it guesses, confidently, the way these systems do when they have nothing to ground them.</p><h3>Why the file has to be written by the tool, not by you</h3><p>The instinct is to write this yourself. Resist it.</p><blockquote><em>A file you write records what you meant to do. A file the tool writes records what it actually did, including the three things you did not notice it doing and the workaround it applied at minute fourteen while you were reading something else.</em></blockquote><p>She also had it generate small scripts that check whether each connection is still healthy, one per thing that can independently break. Those are still in her project. They are now the first thing she runs when anything looks wrong.</p><p>That distinction matters more than it sounds. When her setup broke, the useful information was never “the connection is down.” It was that one service authenticated and the other returned a specific error, which immediately ruled out half the possible causes.</p><p>A single script checking everything and printing one pass or fail would have told her nothing she did not already know.</p><pre>On failure, print the full error including any status code,<br>and print which command produced it. Do not swallow errors<br>or exit silently.</pre><p>That instruction matters more than it looks. The default instinct of generated scripts is to fail quietly, which produces exactly the useless “something is wrong” signal you were trying to escape. You have to ask for the noise.</p><p>The other thing worth insisting on: run each script once while everything is known to be working, then deliberately break one thing and run them again. A verification script you have never seen fail is not a verification script. You have no idea whether it is checking anything at all.</p><h3>The three ways this goes wrong</h3><p>There is a version of this that is worse than having no file at all, and I have watched each one happen.</p><p>The first is staleness. A handoff written three sessions ago and never updated does not fail loudly. It fails by being confidently followed, and you end up debugging a problem that exists only because your own documentation lied to you.</p><blockquote><em>A stale handoff is not neutral. It is a wrong answer in your own handwriting.</em></blockquote><p>The rule I settled on is unglamorous: update it at the end of any session that changed something, or delete it. There is no third option that survives a real project.</p><p>The second is secrets. When you ask a tool to document how it connected to something, it will sometimes helpfully include the credential it used. That file is now a liability, and if it ever gets committed the secret is in the history permanently, even after you delete it. The instruction has to say paths only, and you have to check afterwards. Two of the four professionals I taught last month <a href="https://aitutorcode.com/blog/ways-beginners-leak-credentials-with-ai-tools">exposed a live credential in their first three sessions</a>, so this is not hypothetical.</p><p>The third is the least obvious and the most common. My student once opened her project from inside the tool’s own hidden configuration folder rather than the real project directory. Nothing warned her. Everything ran normally. But the reports were invisible from where she was working, and for a while it looked as though the technique had simply not worked. Most of the time the file is not missing. You are standing in the wrong folder.</p><h3>What the habit is actually for</h3><p>I taught some version of this to all four of the professionals I worked with last month. It is the only technique that showed up in every single engagement, and the only one that ever recovered a broken system without me in the room.</p><p>With a business owner it was “always tell it to report back.” With a technical artist it was a running file of what works and what does not. With a long-running student it landed as something sharper that has stuck with me: marking a task complete gives you nothing, but writing down what you actually did builds a knowledge base as a byproduct of work you were doing anyway.</p><blockquote><em>She told me at the end of that session that she felt she had come a long way in a short time. What had actually changed was not her skill. It was that her setup could now explain itself.</em></blockquote><p>The reason I push this on people who are not developers, and who reasonably wonder why they are being asked to write files at all, is that it moves the memory burden off them.</p><p>My students forget things. Not through inattention, but because they are doing this alongside a full job, and the volume of new concepts in a session outruns what anyone can hold. The student in this story could not reliably recall how to switch modes four sessions in, and she is one of the sharpest people I work with. That is not a knowledge problem to solve with more explaining. It is a storage problem to solve with a file.</p><p>There is a version of teaching where you solve the problem while the student watches. They leave impressed and helpless. This is the opposite of that, because the thing you build is not the fix. It is the capacity to be fixed.</p><blockquote><em>A student stopped me mid-build once and said: do not teach me your one thing, teach me to think in the AI way. That is the same instinct, expressed better than I have ever managed.</em></blockquote><p>It also happens to be the only defence against how fast this field moves. I watched a genuinely capable model get withdrawn worldwide this summer, days after launch, for reasons that had nothing to do with quality. Students who had learned that model’s buttons lost something. Students who had learned to record what they did, check the output, and hand off cleanly lost nothing, because all of that moved to the next tool in a single session.</p><p>The file is not really about the file. It is about not being the only place your project’s memory lives.</p><p>If you want the step by step, I wrote it up as <a href="https://aitutorcode.com/blog/claude-code-handoff-file">a walkthrough for building a handoff file</a>, including the part where you deliberately break something to check the verification scripts fail when they should.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0196bdd64119" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why Does Your AI Forget What You Just Told It?]]></title>
            <link>https://medium.com/@michaeltutor/https-aitutorcode-com-blog-the-pronoun-that-made-our-chatbot-lie-403d5089bdf1?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/403d5089bdf1</guid>
            <category><![CDATA[claude-code]]></category>
            <category><![CDATA[anthropic-claude]]></category>
            <category><![CDATA[claude-ai]]></category>
            <category><![CDATA[claude]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Fri, 14 Aug 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-08-14T13:01:02.453Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*vyHwIEadgK8LXtzyfd_h2Q.png" /></figure><p>I used to explain this badly. For a long time I would tell students that the model has a memory limit, they would nod, and then a week later they would ask why their assistant had forgotten a rule they set at the top of the conversation.</p><p>The explanation was not wrong. It was just abstract enough to be useless.</p><p>What finally fixed it was watching a chatbot invent a year that does not exist, in front of a student, thirty seconds after answering the same kind of question perfectly. Once you see the failure happen, the mechanism stops being a fact you memorise and becomes something you can predict.</p><p>So here is the version I give now, built out of things that actually went wrong in sessions rather than out of documentation.</p><h3>the model does not remember anything, it re-reads everything</h3><p>This is the whole thing, and almost every confusing behaviour follows from it.</p><p>Language models are stateless. Each request arrives with no knowledge of the one before it. What feels like a conversation is the entire transcript being re-sent from the top, every single time, so the model can re-read it and continue.</p><p>Nothing is recalled. Everything is resent. Anthropic’s own <a href="https://docs.claude.com/en/docs/build-with-claude/context-windows">documentation on context windows</a> says the same thing in more formal language, if you want it from the source rather than from me.</p><p>Once that sentence is properly in your head, a lot of otherwise baffling things become obvious:</p><ul><li>Why a long chat gets worse the longer it runs</li><li>Why starting a fresh session fixes problems no amount of rephrasing would</li><li>Why a constraint you set forty messages ago quietly stops being followed</li><li>Why the same prompt behaves differently on Monday and Thursday</li></ul><h3>a pronoun is the cheapest way to find the bug</h3><p>We had a retrieval chatbot working. A student asked who one of the people in the dataset was, and it came straight back with the correct answer, pulled from real records. We checked it against the raw data.</p><p>Then he typed a follow-up. Four words: “what is her performance history.”</p><p>It answered instantly and confidently. It gave dates. It gave a review cycle. It gave a year that appears nowhere in the data, for a person whose record it had read correctly half a minute earlier.</p><p>Nothing had broken. The retrieval was fine, the model was fine, the data was fine. There was simply no conversation history, so the word “her” pointed at nothing, and a model handed a pronoun with no subject does not stop and ask. It fills the gap.</p><p>If you are building anything that takes follow-up questions, test it with a pronoun before you ship it. It is the fastest way to find out whether your memory is actually wired up.</p><p>The words that expose it fastest, in my experience:</p><ul><li>“her”, “his”, “their” pointing back at a name from the previous turn</li><li>“that one”, “the second one”, “the other option”</li><li>“do it again but”</li><li>“why”, with no object, right after a long answer</li></ul><p>Every one of these requires the previous turn to exist. If it does not, the model will not tell you. It will answer anyway.</p><h3>the same mechanism runs the other way, and it costs money</h3><p>A few weeks later the same student came back with a different problem, and it took me a while to notice it was the same problem wearing a different coat.</p><p>He had set two AI agents to debate each other, left them running, and burned roughly a thousand dollars in a single day. Not on the most expensive model available.</p><p>We worked it out from first principles rather than guessing at symptoms. Every turn re-sends the whole transcript. With two agents, both transcripts grow, and they grow on both sides at once. The first message is short. By the twentieth exchange every message carries the entire history of the argument with it, and all of it is re-read and paid for.</p><blockquote><em>Too little history and it lies to you. Too much and it bankrupts you. One mechanism, two failures, sitting at opposite ends of the same dial.</em></blockquote><p>What made it expensive specifically:</p><ul><li>Both sides of a debate grow, so the cost compounds rather than adds</li><li>Message length grows too, not just message count</li><li>Models will not stop on their own, they are happy to keep going indefinitely</li><li>Nothing in the loop was watching elapsed time or consumed context</li></ul><p>None of that is exotic. It is the same re-reading, running unsupervised.</p><h3>subscriptions protect you from this, raw API access does not</h3><p>There is a second trap layered underneath, and it catches people at work more than at home.</p><p>Subscription products carry usage limits and automatic compaction, because the provider does not want you consuming far more than you paid for. Those limits feel annoying right up until you move to raw API access, where none of them exist.</p><p>My student was on an API key. Nothing was protecting him from himself, and nothing was designed to.</p><p>This is worth checking if your company handed you access rather than you buying it, because a corporate gateway usually means <a href="https://aitutorcode.com/blog/when-your-company-blocks-claude-cowork">API access rather than a subscription</a>, which is the version with no brakes.</p><p>Two questions worth asking whoever gave you the key:</p><ul><li>Is there a spending cap on this account, and who gets alerted when it is hit?</li><li>Am I on an API key or a subscription, and do I therefore have the app and the browser chat at all?</li></ul><p>Three of the four professionals I taught last month were on employer-issued access, and none of them knew the answer to either question when I asked.</p><h3>the fixes are boring and they work</h3><p>There are only really five, and they all follow from the same fact:</p><ol><li>Put stoppers in. If points B and C are settled, stop re-sending them every turn.</li><li>Watch consumed context and elapsed conversation time, and set a limit before you set anything running.</li><li>Tune effort per task. Not every check needs maximum reasoning.</li><li>Right-size the model. Medium effort on a mid-tier model covers most evaluation work.</li><li>Run independent things in parallel rather than in one growing conversation.</li></ol><p>None of these are clever. They are the equivalent of closing the tap.</p><h3>stop at seventy percent, not at the error</h3><p>This is the habit I now teach everyone, regardless of level, and it is the one that changed the most for my students.</p><p>Context degrades as it fills. When it fills completely, the tool compacts the conversation automatically and loses detail doing it. You want to control that moment rather than have it happen to you.</p><p>So: check how full you are, and at around seventy percent, while everything is still clean, write a handoff file describing where things stand. Then open a fresh session pointed at that file.</p><p>You lose the transcript and you keep the substance. That is the right trade every time.</p><p>What goes in the handoff, in order of how much it saves you later:</p><ol><li>What state everything is in right now, and what is half finished</li><li>The exact commands or steps that worked, including any workaround</li><li>Where credentials live, as file paths only, never the values</li><li>What the next session should do first</li></ol><p>The reason to write it at seventy percent rather than at the end is that by the end, the thing writing it is already degraded. You want the handoff produced while the context is still clean.</p><h3>the question that solves most of these</h3><p>When a tool behaves strangely, the instinct is to ask what is wrong with the model. That question has no useful answer.</p><p>The better one: what does this thing actually know at the moment I asked?</p><p>That question has a real answer, you can usually work it out in about a minute, and it explains far more of what goes wrong than any amount of prompt tweaking. Half the problems my students bring me dissolve on that question alone.</p><p>Working through it looks like this:</p><ul><li>Is this a fresh session, or a continuation?</li><li>Did I actually tell it the thing I am assuming it knows, in this conversation?</li><li>Has the conversation run long enough to have compacted and dropped detail?</li><li>Am I referring to something with a pronoun that only exists in an earlier turn?</li></ul><p>Nine times out of ten one of those four is the answer, and none of them require understanding anything about how the model works internally.</p><h3>what I got wrong for years</h3><p>I taught this as a limitation. Something to work around, a rough edge that better models would eventually sand off.</p><p>That framing is wrong, and it made my students passive about it. Statelessness is not a bug being fixed. It is the shape of the thing.</p><p>Once you treat conversation history as a resource you are spending rather than a feature you have been given, both failure modes become manageable. You stop assuming it remembers, and you stop letting it accumulate forever.</p><p>The shift in practice is small:</p><ul><li>Say the thing again in a new session instead of assuming</li><li>Watch how full the context is, rather than waiting for quality to drop</li><li>Write the handoff before you need it</li><li>Put a limit on anything you leave running unattended</li></ul><p>None of that is technical. It is closer to a filing habit than a programming skill, which is exactly why it transfers to people who do not write code.</p><p>The student who watched the chatbot invent a year now writes handoff files without being asked. Not because I explained it better the second time, but because he saw it fail once and the mechanism became real.</p><p>If you want the fuller version of that session, I wrote it up as <a href="https://aitutorcode.com/blog/the-pronoun-that-made-our-chatbot-lie">the pronoun that made our chatbot lie</a>, including the part where the fix took two minutes and the thirty seconds before it were what mattered.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=403d5089bdf1" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Do You Need a Powerful Computer to Use AI in 2026?]]></title>
            <link>https://medium.com/@michaeltutor/https-aitutorcode-com-blog-do-you-need-a-powerful-computer-for-ai-e699ef4e4fbe?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/e699ef4e4fbe</guid>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[information-technology]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Fri, 07 Aug 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-08-07T13:01:02.722Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*oNsZgNIZvcvyAwXrJZq2fg.png" /></figure><p>I get asked this more than almost anything else, and it is usually a stand-in for a different question. People are not really asking about specifications. They are asking whether they are equipped to start at all, and the hardware question is a socially acceptable way to ask it.</p><p>So here is the honest version, because the answer is more encouraging than most people expect in one direction and more brutal in another.</p><p>To use AI tools, you need far less machine than the internet tells you. The model runs in a data center, not on your desk. What runs locally is a text window and some file editing, which is closer to running a word processor than a game. Most of the “you need a serious graphics card” advice comes from people running models locally, which is a hobby and a research activity, not what a working professional does to get a job done.</p><p>But there is a version of this where your machine genuinely stops you, and it has nothing to do with power. I watched it happen twice in one month with the same student, and it cost him most of two paid sessions before we solved it.</p><p>The confusion is that “powerful” and “current” are different properties, and only one of them matters for this.</p><p>Here is the answer, split by what you are actually trying to do:</p><ul><li>If you are only using AI tools: almost any machine from the last five years</li><li>If you are running an editor and a terminal: 16GB, and an operating system that still gets updates</li><li>If your laptop is genuinely old: this is the one case where the machine really does stop you</li><li>If you want to run a model on your own hardware: this is where specifications finally matter</li><li>If you want to train or fine-tune: a completely different budget</li><li>If you are still not sure: start on what you already own</li></ul><h3>If you are only using AI tools: almost any machine from the last five years</h3><p>This covers most people reading this, and it is the least glamorous answer available.</p><p>When you use Claude, ChatGPT, or any hosted assistant, the model itself is running on the provider’s servers. Your machine sends text and receives text. It is doing almost nothing computationally interesting.</p><p>That is why the hardware conversation online is so distorted. The people writing about GPU requirements are solving a different problem than the one you have.</p><blockquote><em>If the model runs somewhere else, your graphics card is not involved in any part of a normal session. It is genuinely that simple.</em></blockquote><p>A browser and a stable internet connection is the real requirement. Anthropic’s own <a href="https://docs.claude.com/en/docs/claude-code/setup">Claude Code setup documentation</a> lists an operating system and a runtime, not a graphics card.</p><h3>If you are running an editor and a terminal: 16GB, and an OS that still gets updates</h3><p>Once you move past chat into tools that work on your actual files, you are running local software. Not a model, but real software: an editor, a terminal, a browser, all open at once.</p><p>The practical floor is memory. 8GB works and you will feel it. 16GB is comfortable, and comfortable matters more than it sounds when you are learning, because a machine that stutters makes you think you did something wrong.</p><p>The second requirement is the one people skip. Your operating system needs to still be receiving updates, because current software increasingly refuses to install on versions that are not.</p><blockquote><em>Nobody upgrades because their machine is slow. They upgrade because something will not install, and that is a much more sudden problem.</em></blockquote><h3>If your laptop is genuinely old: this is the one case where the machine really does stop you</h3><p>Here is the part I did not expect to be writing.</p><p>One of my students spent most of two paid sessions fighting a laptop that was roughly ten years old. His editor took most of an hour to open. The desktop app for the tool his entire project depended on would not launch at all, which meant the thing he was paying to learn was simply unavailable.</p><p>We worked around it twice. Then he borrowed a three-year-old machine, and every single thing worked immediately. Nothing about the task had changed. Only the hardware had.</p><p>That is a different failure from being slow. Slow is annoying. This was a hard stop, and neither of us saw it coming because the machine ran a browser fine.</p><blockquote><em>A ten-year-old laptop will not tell you it is the problem. It will let you believe you are the problem, which is far more expensive.</em></blockquote><p>If your machine no longer gets operating system updates, expect installation failures before you expect performance issues, and do not read those failures as a verdict on you. This is one of <a href="https://aitutorcode.com/blog/setup-problems-that-stall-ai-beginners">six setup problems that stall almost every beginner</a>, and it is the one that does the most quiet psychological damage.</p><h3>If you want to run a model on your own hardware: this is where specifications finally matter</h3><p>There is a real case for this and it is worth understanding before deciding you want it.</p><p>The reasons are genuine: nothing leaves your machine, there is no per-token bill, and it works offline. If you handle sensitive material under a strict data policy, that combination is properly attractive.</p><p>The cost is that the model now has to fit in your memory, and a model good enough to be worth the trouble wants somewhere between 16 and 24GB of dedicated video memory. There is a compression technique that shrinks models to fit smaller hardware, and it works, but compression loses quality and how much you notice depends entirely on what you are asking it to do.</p><blockquote><em>For summarising a document, compressed models are fine. For anything needing careful reasoning, the loss shows up faster than the enthusiast benchmarks suggest.</em></blockquote><p>Unless a data policy forces your hand, a hosted model costs you nothing in hardware and gives you a better result.</p><p>There is a longer-horizon version of this argument that I find genuinely persuasive and still would not act on yet. A student of mine is convinced open models will make hosted ones unnecessary for most people within two years, and he may well be right about the models. My hesitation is not about capability. Memory on a phone, a laptop, and a desktop are not the same thing, the data transfer speeds differ meaningfully between them, and battery is a hard physical limit nobody has solved. Run a model locally on a phone today and one or two prompts will visibly drain it.</p><p>Bet on that if you want. Just do not buy hardware for it this year.</p><h3>If you want to train or fine-tune: a completely different budget</h3><p>Three things get confused here constantly, and conflating them is exactly why people buy the wrong card.</p><p><strong>Training</strong> builds a model from scratch. <strong>Fine-tuning</strong> adjusts an existing model on your own data. <strong>Quantization</strong> shrinks an existing model to fit smaller hardware. Three activities, three completely different hardware requirements.</p><p>Real training wants data-center class hardware, roughly seven to fifteen thousand dollars for the card alone. Fine-tuning is cheaper and usually fits on rented cloud compute. Quantization is cheaper still.</p><p>My advice to every student who raises this: rent before you buy. Find somewhere to rent the compute, run your actual project on it, confirm it does what you need, and only then decide whether owning it makes sense.</p><blockquote><em>I have a note in my files about someone who bought an expensive card specifically to run a local model and abandoned the project entirely. The card was never the bottleneck. Interest was.</em></blockquote><h3>If you are still not sure: start on what you already own</h3><p>The hardware question is almost always a proxy, and treating it as a real technical question lets you postpone the thing you actually wanted to do.</p><p>Open your machine. Check it still gets operating system updates. If it does, you are equipped, and you will find out within two sessions whether it is genuinely the constraint. If it turns out to be, you will know exactly what to buy, which is a much better position than guessing now.</p><p>The four professionals I worked with last month were all sharp, senior, and good at their jobs. What actually stopped them was a docking station, a vocabulary problem, an IT policy, and a habit nobody had mentioned. Not one of them was stopped by a lack of processing power.</p><blockquote><em>The machine on your desk is almost certainly fine. The thing you are short of is someone to tell you what to do with it.</em></blockquote><p>If you want the longer version, I wrote up <a href="https://aitutorcode.com/blog/do-you-need-a-powerful-computer-for-ai">what computer you actually need for AI work</a> with the full breakdown by task.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=e699ef4e4fbe" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[AI Answered Everything. I Still Found a Teacher.]]></title>
            <link>https://medium.com/@michaeltutor/ai-answered-everything-i-still-found-a-teacher-ab4bd937b570?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/ab4bd937b570</guid>
            <category><![CDATA[career-change]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[education]]></category>
            <category><![CDATA[self-improvement]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 16:01:02 GMT</pubDate>
            <atom:updated>2026-07-28T16:01:02.821Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_NUBWXm6BIG4HDyMZWCT1A.png" /></figure><p>He stopped me about fifteen minutes into our first session, politely, the way someone interrupts when they have been holding a thought too long to wait any further. He runs his own business, taught himself most of what he knows, and he is not short on confidence or resources. He had an AI subscription that would answer literally any question he could type, instantly, at two in the morning, for the price of a sandwich.</p><p>And yet here he was, paying for a human being. I asked him why, gently, because it is a fair question and I would rather hear the real answer than assume.</p><p>What he said reframed how I think about my whole job. He did not want me to hand him answers. He had infinite answers already. What he wanted, in his words, was to learn to think in the AI way. To be taught how to fish, not handed a fish, so he could turn the same way of thinking on his business, and the next one, and whatever came after.</p><h3>The thing infinite answers do not give you</h3><p>Here is what a year of watching capable people learn with AI has taught me. The answer was never the scarce resource. It has not been scarce for a while, and now it is effectively free. What stayed scarce is everything around the answer.</p><p>Knowing which question to ask. Being able to tell whether the answer you got is actually right, or just confident. Knowing what you do not know well enough to even sense the gap. None of those arrive in the reply box. An AI will answer the question you asked with total assurance, including when you asked the wrong question, and it will never once tell you that you asked the wrong question.</p><blockquote><em>AI made every answer free. It did not make me able to tell which answers were right.</em></blockquote><p>That gap is exactly where a teacher still earns their place. Not as a faster search engine, the machines won that race years ago, but as the person who notices the wrong turn before it becomes three weeks of rework, who asks the question you would never have thought to ask, and who can tell when the confident answer in front of you is quietly wrong.</p><h3>Why the smartest self-learners still stall</h3><p>The man in my session was not unusual. Some of the most capable people I work with come to me precisely because they have already tried the solo path, often more than once. They have a graveyard of half-finished courses behind them, and now a chat history full of perfect answers they somehow still did not turn into skill.</p><p>The reason is not intelligence and it is not the quality of the material. The free material is excellent. It is that learning alone has almost no force holding you through the dip, the week in month two when the novelty is gone and the difficulty is not. The completion numbers tell the story plainly: self-paced online courses see <a href="https://www.katyjordan.com/MOOCproject.html">completion rates somewhere between five and fifteen percent</a>, while the students I work through a structured one-on-one program with finish at around ninety percent. That gap is not a content gap. It is a gap in follow-through, in having a standing appointment and a person who notices when you go quiet. I dug into why that gap is so stubborn in <a href="https://aitutorcode.com/blog/mooc-completion-rate">the real numbers behind course completion</a>, and AI, for all it changed, did not close it. If anything, infinite easy answers make it easier to feel like you are learning while you are mostly collecting.</p><h3>What a teacher gives that a model cannot</h3><p>I am not romantic about this, and I am the first to tell a self-disciplined, already-technical person that they may not need me at all. I wrote out exactly who still benefits and who does not in <a href="https://aitutorcode.com/blog/do-you-still-need-a-coding-tutor">whether you still need a coding tutor in the age of AI</a>, and for some people the honest answer is no.</p><p>But for the person who wants to learn to think, not just to receive answers, the value is concrete. A teacher gives you the question behind the question. A teacher holds you to a rhythm so the dip in month two does not end the whole thing. A teacher reads your frustration and adjusts, which no prompt has ever done for anyone. And a teacher teaches the transferable move, the way of breaking a problem down and directing a tool and checking its work, which is the thing that survives every model change. That is the meta-skill I try to build in every student, and I wrote about it directly in <a href="https://aitutorcode.com/blog/teach-me-to-think-in-the-ai-way">what it means to think in the AI way</a>.</p><p>That last part matters more than it used to. The specific model my student used in our first session may not be the one he uses next year. Tools change, get repriced, sometimes vanish entirely. The way of thinking does not. A model gives you this week’s answers. A teacher, at their best, gives you a way of working that makes the next model just a new engine for the same skill.</p><h3>The honest reframe</h3><p>So the question is not really “do I still need a teacher when AI can answer anything.” The question is what you are actually trying to get. If you want an answer, the machine is faster, cheaper, and available at two in the morning, and you should use it without guilt. If you want to become the kind of person who can tell a good answer from a confident wrong one, and who can keep going when the material stops being fun, that is a different thing, and it is still mostly built by another human being who has watched a few hundred people make the same turn.</p><p>My student finished that first session with a plan, not a pile of answers. He did not need me to know things. He needed someone to help him become someone who knows how to think with these tools, and that, it turns out, is the one thing the answer box does not sell.</p><p>If that is the kind of learning you are after, a free <a href="https://aitutorcode.com/contact">Discovery Call</a> is a good place to start, and I will tell you honestly if the solo path is genuinely all you need.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=ab4bd937b570" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[You Are Not Too Non-Technical for Claude Code]]></title>
            <link>https://medium.com/@michaeltutor/you-are-not-too-non-technical-for-claude-code-8a1c4424f2d4?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/8a1c4424f2d4</guid>
            <category><![CDATA[python-programming]]></category>
            <category><![CDATA[software-engineering]]></category>
            <category><![CDATA[artificialintelligenceai]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <category><![CDATA[future-technology]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Fri, 24 Jul 2026 16:06:01 GMT</pubDate>
            <atom:updated>2026-07-24T16:06:01.702Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nZwdN70M-zHZ0OPc9w10ug.png" /></figure><p>The question I get most often from non-developers eyeing Claude Code is some version of this: will I break something, and will I even be able to set it up at all? It comes with a particular anxiety, because Claude Code lives in a terminal, and the terminal is the part of computing most professionals have spent a career carefully avoiding.</p><p>So here is the honest answer, up front. Yes, you can set it up. No, you will not break anything. And the only genuinely hard part is a fear that tends to evaporate the first time an error turns out to be completely routine. Let me walk you through the real shape of it, so the fear has nothing to hide behind.</p><h3>Why it looks scarier than it is</h3><p>Three things make Claude Code feel intimidating, and none of them are about your ability. The first is the terminal itself, that text-only window most people have never opened. The second is that the setup assumes a little developer vocabulary it does not stop to explain. The third is that, on Windows, it runs best inside something called WSL, which is one more unfamiliar word on top of the pile.</p><p>Stacked together, that looks like a wall. Taken one at a time, in order, it is a forty-five minute setup that a complete beginner can finish. The wall is mostly made of unfamiliarity, and unfamiliarity dissolves the moment someone names each piece for what it is.</p><h3>The path, in order</h3><p>You do not need to memorize this. You need to see that it is short and linear, not a maze. The full step-by-step with the exact commands lives in <a href="https://aitutorcode.com/blog/set-up-claude-code-windows-wsl">the guide to setting up Claude Code on Windows and WSL</a>, but here is the shape so it stops feeling mysterious.</p><ul><li><strong>Turn on WSL.</strong> One command installs a small Linux environment that Windows already ships with. You restart once. This is the part that sounds exotic and is actually a single line.</li><li><strong>Install Node.</strong> Claude Code needs it. One install, one line to confirm it worked.</li><li><strong>Install Claude Code and sign in.</strong> One more install, then it walks you through logging in with your account.</li><li><strong>Give it your context.</strong> Before you ask for anything, you write a short file that tells Claude who you are and how you work, which is the single move that makes everything afterward better.</li><li><strong>Run one real task.</strong> Something small and true, so the first thing you ever do ends in a visible win.</li></ul><p>Five steps, mostly one line each. That is the whole intimidating thing, laid flat.</p><h3>The one error that stops most beginners</h3><p>I want to name this one specifically, because it is the single most common place people quit, and it is almost insultingly minor once you know it. After you install something, the terminal sometimes says <em>command not found</em>. Beginners read that as “I broke it” or “I am not capable.” It means neither. It almost always means the terminal has not noticed the new install yet, and the fix is to close the window and open a fresh one.</p><blockquote><em>The error that stops the most people is the one that takes the least effort to fix. It is not a wall. It is a speed bump wearing a costume.</em></blockquote><p>This happens to experienced developers constantly. They have just learned to shrug at it. The entire difference between a beginner who quits here and one who keeps going is whether someone told them in advance that this moment is normal. Consider yourself told.</p><h3>What makes it actually click</h3><p>Two things turn a working installation into something useful. The first is context. Before you ask Claude Code to do anything, you write it a short standing brief, a file that captures your project, your tools, and your rules, so it starts every session already knowing you. I explain exactly what goes in one in <a href="https://aitutorcode.com/blog/what-is-claude-md-file">the guide to the CLAUDE.md file</a>, and it is the highest-leverage twenty minutes in the whole setup.</p><p>The second is starting with a real project, not a toy. The fastest way to make the tool make sense is to build something you will actually keep. <a href="https://aitutorcode.com/blog/build-portfolio-website-claude-code">Building a simple portfolio website</a> is a good first one, because it ends with a live page you can show people, and nothing teaches a tool like watching it produce something real. Anthropic’s own <a href="https://code.claude.com/">Claude Code documentation</a> covers the install specifics if you want the canonical reference alongside the guide.</p><h3>The honest part: it might not be your tool yet</h3><p>Here is the answer most setup guides will not give you. Claude Code is the more technical door, and for a lot of professionals it is the wrong first one. If your goal is to get real work done on your files, documents, reports, data, without writing code, you may be happier starting somewhere friendlier and coming back to Claude Code later, if at all. I lay out that choice plainly in the <a href="https://aitutorcode.com/blog/chat-vs-cowork-vs-claude-code">breakdown of chat versus Cowork versus Claude Code</a>.</p><p>I would rather tell you that than have you grind through a terminal setup you did not need. The fear of Claude Code is worth dissolving either way, because it is a fear about your own capability, and that one follows you everywhere. But the tool itself is a choice, not an obligation.</p><p>If you want to set this up with someone on the call the first time an error appears, so it lands as routine instead of a roadblock, a free <a href="https://aitutorcode.com/contact">Discovery Call</a> is the fastest way through. Most people are running their first real task inside the first session, and the fear does not survive that.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=8a1c4424f2d4" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Marketing Work I Stopped Doing by Hand]]></title>
            <link>https://medium.com/@michaeltutor/the-marketing-work-i-stopped-doing-by-hand-7ccda531237c?source=rss-7f2ff785a744------2</link>
            <guid isPermaLink="false">https://medium.com/p/7ccda531237c</guid>
            <category><![CDATA[technology]]></category>
            <category><![CDATA[ai-prompt-engineering]]></category>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[learning-to-code]]></category>
            <dc:creator><![CDATA[Michael Murr]]></dc:creator>
            <pubDate>Tue, 21 Jul 2026 16:56:01 GMT</pubDate>
            <atom:updated>2026-07-21T16:56:01.511Z</atom:updated>
            <content:encoded><![CDATA[<figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*s7_ey4SU6bNqPkPFmxoPpA.png" /></figure><p>For years I wore the repetitive parts of marketing work like a badge. The weekly performance report. The monthly ad audit. The win-loss read on closed deals. The endless reshaping of one good idea into eight formats. I told myself that doing it carefully, by hand, every time, was the job. It was not the job. It was the tax on the job, and I had quietly accepted paying it.</p><p>What changed my mind was not a productivity hack. It was watching how much sharper my actual thinking got once the busywork stopped eating the hours around it. So here is the honest account of the marketing work I handed to Claude, what broke along the way, and what actually stuck.</p><h3>The work I handed over</h3><p>None of these are hard. That is exactly why they are worth handing off. They are important, repetitive, and a slow drain on the week, which is the precise shape of work an AI coworker is good at.</p><ul><li><strong>The weekly ad audit.</strong> Checking budget pacing, whether the targeting still matches the buyer, which creative is quietly dying. The same checks, every Monday, forever.</li><li><strong>Win-loss analysis.</strong> Reading back through closed-deal notes to see what actually separated the wins from the losses. Data I always had and rarely used.</li><li><strong>The recurring report.</strong> The same pull, the same shaping, the same layout, every single month, before anyone even reads it.</li><li><strong>Content repurposing.</strong> Turning one webinar or article into the week’s posts and emails, in a voice that still sounds like me.</li><li><strong>The competitive scan.</strong> Skimming competitor pages for the one pricing or messaging change worth reacting to, and ignoring the noise.</li></ul><p>I worked through each of these as a concrete recipe in a longer piece on <a href="https://aitutorcode.com/blog/marketing-tasks-automate-with-claude">the marketing tasks you can automate with Claude</a>, with the actual prompts. The short version is that every one of them moved from a thing I did to a thing I reviewed, which is a much smaller job.</p><h3>What broke, and what I learned</h3><p>It did not all work on the first try, and the pieces that broke taught me more than the pieces that worked.</p><p>The drafts needed editing. The first content Claude produced in “my voice” was generic until I actually fed it real examples of how I write and kept them in its standing instructions. The reports were sometimes confidently wrong until I told it to cite which source each number came from, so I could check. And the most useful shift was the smallest: I stopped asking it to summarize and started asking it to evaluate. A summary tells you what a thing said. An evaluation tells you whether it was any good against a standard you set, and that is the part that actually saves judgment time.</p><blockquote><em>I did not automate my judgment. I automated everything that was stealing time from it.</em></blockquote><p>That is the line I keep coming back to. The fear with marketing automation is that it flattens your taste into something generic. The reality, if you do it right, is the opposite. By handing off the assembly and the formatting, you free up the hours and the attention for the part only you can do: deciding what the numbers mean and what to do about them.</p><h3>You do not need to code to do any of this</h3><p>This is the part that stops most marketers before they start, and it should not. None of what I described requires writing code or opening a terminal. It runs in Claude’s Cowork, which is built for exactly this kind of non-technical, file-and-document work. If you have wondered whether these tools are only for engineers, the honest answer is in <a href="https://aitutorcode.com/blog/can-a-non-coder-use-claude-code">whether a non-coder can actually use Claude</a>, and for marketing work the answer is a clear yes.</p><p>If you want the gentlest on-ramp, I wrote a plain walkthrough of <a href="https://aitutorcode.com/blog/set-up-claude-cowork">setting up your first task</a> that takes about an hour and ends with one annoying job off your plate for good. Anthropic’s own <a href="https://www.anthropic.com/product/claude-cowork">Cowork page</a> covers what it can reach on your machine.</p><h3>The lesson under the lesson</h3><p>The work I stopped doing by hand was never the work that made me good at my job. It was the work that stood between me and the part that did. Every hour I used to spend formatting a report was an hour not spent deciding what the report should change.</p><p>That is the reframe I would offer any marketer eyeing these tools warily. You are not handing over the craft. You are handing over the chores that were quietly crowding the craft out. The taste, the strategy, the read on what a campaign is really telling you, that stays yours, and it gets sharper when it is the thing you spend your best hours on instead of the last thing you get to after the busywork is done.</p><p>If you want help working out which parts of your week are tax and which parts are the actual job, a free <a href="https://aitutorcode.com/contact">Discovery Call</a> is a good place to draw that line for your specific role.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7ccda531237c" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>