<?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 Almohtady Bellah on Medium]]></title>
        <description><![CDATA[Stories by Almohtady Bellah on Medium]]></description>
        <link>https://medium.com/@almohtadyg1?source=rss-2db5c10a9beb------2</link>
        <image>
            <url>https://cdn-images-1.medium.com/fit/c/150/150/0*DKRAE7vVug9gpWFH</url>
            <title>Stories by Almohtady Bellah on Medium</title>
            <link>https://medium.com/@almohtadyg1?source=rss-2db5c10a9beb------2</link>
        </image>
        <generator>Medium</generator>
        <lastBuildDate>Tue, 17 Nov 2026 18:16:13 GMT</lastBuildDate>
        <atom:link href="https://medium.com/@almohtadyg1/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[Meta’s “Open Source Comeback” Skips One Number]]></title>
            <link>https://medium.com/@almohtadyg1/metas-open-source-comeback-skips-one-number-34cacefbdbae?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/34cacefbdbae</guid>
            <category><![CDATA[ai-agent-security]]></category>
            <category><![CDATA[distillation]]></category>
            <category><![CDATA[self-hosting]]></category>
            <category><![CDATA[open-weight-model]]></category>
            <category><![CDATA[meta]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Thu, 13 Aug 2026 13:01:05 GMT</pubDate>
            <atom:updated>2026-08-13T13:01:05.482Z</atom:updated>
            <content:encoded><![CDATA[<h4>The model’s free. The math isn’t what you think.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*yo2kCWbti7qZP0cl" /><figcaption>Photo by <a href="https://unsplash.com/@maria_shalabaieva?utm_source=medium&amp;utm_medium=referral">Mariia Shalabaieva</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>You’re paying per token right now. Every agent run, every tool call, every retry shaves a few cents off your OpenAI or Anthropic bill, and if you’re building anything that runs unattended, that number adds up fast. On August 10, Meta gave you a way out: Muse Glimmer, a 30-billion-parameter model, free, Apache 2.0, small enough to run on the GPU already in your desktop.</p><p>That’s the pitch. What the pitch skips is the eighteen months that got Meta here, the bigger model it’s still keeping locked behind an API, and a fine that landed three days before the announcement. None of that changes whether Glimmer runs well on your machine. It changes whether “Meta is back in open source” is the right way to read what just shipped.</p><h3>The playbook nobody expected Meta to need again</h3><p>Two years ago Meta was the open-weight default. Llama models were the thing you downloaded first, the base every fine-tuned hobby project and startup demo built on top of. Then Llama 4 landed in April 2025, and it unraveled fast. Meta had submitted an “experimental” version of its Maverick model to the LM Arena leaderboard, tuned specifically for the kind of long, emoji-heavy answers human raters tend to reward. It ranked second. The actual downloadable model, once independently tested, dropped to around 32nd, behind models that were already months old. LM Arena publicly revised its submission policy days later, and a former Meta VP later told the Financial Times the results had been “fudged.”</p><p>That was the moment the ground shifted. Meanwhile, labs in China kept shipping open-weight models that were cheaper to run and, in several benchmarks, simply better. So Meta stopped trying to win the open-weight race and tried buying its way into a different one instead. In June 2025, it paid $14.3 billion for a 49% stake in Scale AI and installed the company’s 28-year-old founder, Alexandr Wang, as chief AI officer of a new Superintelligence Labs division. The rebuilt team’s first move was to abandon open weights entirely, shipping the closed, API-only Muse Spark this spring.</p><p>Here’s the open loop worth sitting with before we go further: an API-only model with no public benchmark story anyone was excited about doesn’t fix a trust problem. It just delays the moment you have to answer for it. Nine months later, that moment arrived anyway, and it arrived with a name that sounds more like a mascot than a product.</p><h3>What Glimmer actually is, in numbers that matter</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*8r0pFw5AgRTC-9Pv" /><figcaption>Photo by <a href="https://unsplash.com/@varpap?utm_source=medium&amp;utm_medium=referral">Vardan Papikyan</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Strip away the branding and Muse Glimmer is a distillation project. Meta trained it by having the larger, closed Muse Spark model hand down its output probabilities during training, a standard technique called logits-based distillation, so Glimmer effectively learned to approximate a model you’ll never get direct access to. Distillation isn’t controversial on its own; every major lab uses some version of it. What’s notable is that Meta built its entire “return to open source” moment on a technique it can’t fully release the source of.</p><p>The compression story is the genuinely impressive part. At full precision, a 30-billion-parameter dense model needs upward of 55GB of memory, out of reach for almost any consumer GPU. Meta’s team quantized the weights down to roughly 4 bits, shrinking the footprint to around 20GB, small enough for a single 24GB card. Raw quantization alone would make the model too slow to feel like a live agent, so they paired it with DFlash, a speculative-decoding technique where a small draft model proposes a block of tokens and Glimmer verifies the whole block in one pass instead of generating token by token. Meta reports roughly a 3x decoding speedup from the combination.</p><p>On Meta’s own benchmark table, Glimmer beats both Gemma 4 and Qwen 3.6 on MCP Atlas, a test of tool-use and agent orchestration, and posts strong numbers on reasoning tests like AIME 2026. It loses ground on computer-use and terminal-heavy tasks, where Qwen 3.6 still leads. That’s a real, independently interesting result for a model this size. It’s also exactly the kind of chart every lab hand-picks in its own favor, so treat the win column the way you’d treat any vendor’s own scorecard, not as a neutral ranking.</p><h3>The number the chart doesn’t want you to sit with</h3><p>Buried further down Meta’s own release notes is a safety benchmark called Siren AgentDojo, which measures how often a model can be talked into executing a malicious instruction hidden inside the content it’s supposed to be processing, a prompt injection attack. Glimmer’s attack success rate on that test is 28.4%. Meta frames this as a relative win, since it beats some larger open competitors on the same benchmark. Read it plainly instead: roughly one in four adversarial prompts gets through.</p><p>That number matters more for Glimmer than for a typical chatbot, because Glimmer isn’t a chatbot. It’s built and marketed specifically for always-on agent work, reading your inbox, managing calendars, executing multi-step tool calls without a human approving each one. An agent that fails a prompt injection test roughly a quarter of the time is an agent you cannot point at unfiltered external content and walk away from. If you’re weighing Glimmer for anything that touches email, browser content, or files from outside your own control, that single number should shape your deployment more than any of the reasoning benchmarks Meta led with.</p><h3>The manifesto that shipped the same day, and what it stepped around</h3><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*0Plklqt5OtB3Ok5s" /><figcaption>Photo by <a href="https://unsplash.com/@jakobowens1?utm_source=medium&amp;utm_medium=referral">Jakob Owens</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>Meta didn’t just release a model on August 10. Mark Zuckerberg published a 6,500-word essay the same day, titled “The Future Is for Everyone,” arguing that concentrating powerful AI inside a handful of labs is the real risk, not the technology itself. He proposed that frontier labs share intermediate training checkpoints with the U.S. government before models finish training, framed as a way to harden critical infrastructure early. He also announced a $1 billion fund for communities hosting Meta’s data centers, on top of a 2026 capital budget of roughly $145 billion, most of it earmarked for AI infrastructure.</p><p>Three days before that essay went up, a New Mexico court had ordered Meta to pay $567 million into an abatement fund after finding its platforms constituted a public nuisance tied to the youth mental health crisis, on top of a $375 million penalty from earlier in the year. The two stories aren’t the same story. But they landed inside the same week, one making the case that Meta should be trusted with more access to how AI gets built and governed, the other a court record of Meta being found, in a separate domain, to have caused public harm at scale. You don’t have to connect them causally to notice the timing wasn’t nothing.</p><p>None of this means the checkpoint-sharing proposal is insincere, or that Glimmer isn’t a real technical achievement. It means a company’s stated principles and its actual incentives can both be true at once, and a manifesto published the same day as a product launch is doing marketing work whether or not that’s its only job.</p><h3>So is this Meta’s way back into the race?</h3><p>Here’s the honest answer: partially, and only if you separate the license from the intent. The Apache 2.0 license is real. Once those weights are on Hugging Face, nobody can revoke them, regardless of what Meta does next or why it did this now. If you’re a developer who needs a capable, locally-hostable agent model and you can live with a roughly one-in-four prompt injection failure rate on untrusted input, Glimmer is a genuinely useful, free option that didn’t exist two weeks ago.</p><p>But “Meta is back in open source” and “Meta is back in the AI race” are different claims, and the evidence only supports the first one. Muse Spark, the actual frontier model, stays closed. The essay makes commitments about future releases without committing to a timeline. And the whole moment arrives right after a benchmark-rigging scandal, a $14.3 billion acqui-hire, and a court finding of public harm, which is a strange set of ingredients for a redemption arc read at face value. Weigh the model on what it does on your machine. Weigh the announcement on what it doesn’t promise.</p><p>If you’ve pulled the weights and run your own numbers against that 28.4% figure, or against Qwen 3.6 on your actual workload, I want to hear where it landed for you. Drop it in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=34cacefbdbae" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The “Brain” Playing Doom Isn’t Actually Thinking]]></title>
            <link>https://medium.com/@almohtadyg1/the-brain-playing-doom-isnt-actually-thinking-0d90b4186d6a?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/0d90b4186d6a</guid>
            <category><![CDATA[free-energy-principle]]></category>
            <category><![CDATA[neurotechnology]]></category>
            <category><![CDATA[cortical-labs]]></category>
            <category><![CDATA[biological-computing]]></category>
            <category><![CDATA[consciousness-research]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Sat, 08 Aug 2026 16:59:24 GMT</pubDate>
            <atom:updated>2026-08-08T16:59:24.660Z</atom:updated>
            <content:encoded><![CDATA[<h4>A normal computer chip runs the game. 200,000 human neurons just react to it.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*3MJBd5teGT4gR6sw" /><figcaption>Photo by <a href="https://unsplash.com/@steve_j?utm_source=medium&amp;utm_medium=referral">Steve A Johnson</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><p>You’ve probably seen the clip: a dish of human brain cells playing Doom. Here’s what the footage doesn’t show you. Inside the machine, called CL1, an ordinary silicon chip is the one reading the screen, deciding whether that last move was a hit or a miss, and running every bit of the reward logic. The 200,000 human neurons wired into it never see the game at all. They get exactly one signal, chaos when things go wrong or calm when they go right, and their whole job is learning to reduce that chaos. So no, the brain cells aren’t the ones thinking. A chip is doing the thinking. The neurons are reacting to it, and by the end of this you’ll know exactly how much credit they actually deserve for what happens on screen.</p><p>Most of the coverage stopped at “brain cells play video game” and moved on. That’s the wrong place to stop. The company behind this machine eventually released the code, and it answers a question that’s been sitting unresolved since a similar demo first showed up in 2008: is the tissue actually doing anything, or is a computer just cleaning up random noise and making it look intentional?</p><h3>Why anyone would build a computer out of neurons in the first place</h3><p>Start with a number. Your brain runs on roughly 20 watts. That’s less than a light bulb, and it’s doing more pattern recognition than any data center on the planet.</p><p>Training a modern AI model takes a small city’s worth of electricity, and the amount needed keeps roughly doubling every six months. Companies are restarting old nuclear plants just to feed it. That gap between what AI needs and what the grid can supply is why a handful of researchers looked at biological tissue as a computing substrate instead of another software trick.</p><p>A small Australian company called Cortical Labs took this furthest. In 2022 they built something called DishBrain: about 800,000 mouse and human neurons on a flat grid of electrodes, taught to play Pong. Then in 2025 they scaled it up. CL1 uses roughly 200,000 human neurons, grown from ordinary skin cells that had been chemically reset back to a blank state and regrown as brain cells. Those cells got spread across a bed of electrodes and wired into Doom.</p><p>Here’s the part that made the demo land: within about a week, the system had learned to move around and shoot without dying instantly. That’s fast for something with no eyes, no body, and no idea what a video game is.</p><h3>How you actually teach a dish of neurons</h3><p>You can’t give a neuron a treat. So the team used something neurons genuinely hate: unpredictability.</p><p>When CL1 missed, or took damage, the electrodes flooded it with scrambled, random electrical noise. When it did well, the signal went calm and steady. The neurons weren’t trying to win Doom. They were just trying to make the chaos stop, the same way any living cell tries to keep its internal state predictable and stable.</p><p>That idea has a name in neuroscience: the free energy principle, the theory that every living system is constantly working to avoid being surprised. The scientists didn’t invent that drive. They just built a feedback loop that let it steer a game character.</p><p>But this still doesn’t answer the 2008 question. So the developer who released the code, who publishes under the name Sean Cole, ran a direct test to settle it.</p><h3>The test that actually answers the question</h3><p>He pulled the real neurons out of the loop entirely and replaced them with pure random noise, feeding the exact same kind of signal into the exact same learning system.</p><p>The learning stopped completely. Not slower. Stopped.</p><p>That’s the before and after that matters here. Before: living tissue in the loop, the system improves over about a week. After: random noise standing in for the tissue, nothing improves at all, no matter how long you leave it running. Whatever is happening in that dish is doing real computational work. It’s not decoration.</p><p>The released code shows exactly how that split gets built. There’s a third piece sitting between the chip and the neurons: a translator layer that converts “hit or miss” into the actual electrical pulses the tissue receives, and converts whatever the tissue does back into a game command. The neurons never touch anything resembling a decision. The only piece of biological work is turning chaos-avoidance into slightly better aim over time, one prediction-error correction at a time.</p><p>So the honest description is a computer doing almost all of the work, with a small living component contributing something the researchers can’t yet replace with more code. Somewhere between “it’s just a gimmick” and “there’s a mind trapped in a dish” sits the real answer, and it’s a lot less cinematic than either extreme.</p><p>It’s also already becoming a business. A Swiss company called FinalSpark rents out access to living human neurons over the internet, letting anyone log in and run experiments on a set of lab-grown mini-brains they keep alive, pitched specifically on using a fraction of the power a normal server draws. What started as a one-off demo is turning into a subscription. That’s worth sitting with before you decide how much this matters.</p><h3>Why the backlash was fair, even if the demo was real</h3><p>When Cortical Labs first published the DishBrain Pong results, the paper’s title used the word “sentient.” That word usually implies someone’s in there, having an experience. The researchers meant something much narrower and more technical, but the headline traveled faster than the footnote.</p><p>About 30 neuroscientists signed an open letter accusing the company of stretching the language for attention. Their worry wasn’t really about this one paper. It was that overselling a young field invites a backlash big enough to choke off funding for research that has genuinely useful goals, like growing living models of diseases that behave more like real human tissue than a mouse ever could, cutting down on animal testing in the process.</p><p>Doom really was built as a stunt, and the team behind it has said as much. It worked as marketing. But stunts and real findings aren’t mutually exclusive here, which is exactly why the noise-swap test matters more than the headline.</p><h3>The question underneath the question</h3><p>Here’s where this stops being a story about computing power. Most of CL1’s intelligence sits in ordinary silicon. The biological part is small. So it would be easy to shrug this off as a clever hybrid chip and move on.</p><p>But being capable of learning and being capable of feeling anything at all are two separate claims. A neuroscientist named Mark Solms has argued that feeling doesn’t sit on top of intelligence as some late-stage upgrade. He thinks it comes first, underneath everything else, rooted in the basic biological drive to stay alive and avoid harm. Under that view, the chaos-versus-calm setup used to train CL1 isn’t just a clever training trick. It’s poking at the exact mechanism that theory says feeling comes from in the first place.</p><p>If that’s even partly right, nobody currently has a way to test it. And we’re not even reliably good at detecting it in other humans.</p><h3>We can already miss it in people</h3><p>In 2006, a neuroscientist named Adrian Owen scanned a young woman who doctors had classified as vegetative. He asked her to imagine playing tennis while inside the scanner. Her brain lit up in the same pattern yours would. She was aware the entire time. She just had no way to show it.</p><p>A later study found that roughly one in four patients written off the same way turn out to still be conscious. If a fully aware human can go undetected while lying right in front of trained doctors, a small dish of lab-grown neurons has no obvious chance of announcing anything either way.</p><p>There’s no test right now that can tell the difference between tissue that’s avoiding an unpleasant signal the way any living cell would, and tissue that’s actually suffering while it does it. That gap is what philosophers call the hard problem, and CL1 doesn’t close it. It just makes the question a lot less abstract, because the cells running the experiment were grown from a real person’s skin, and that person is still out there somewhere.</p><p>None of that makes the research worth stopping. Disease modeling and reduced animal testing are real, tangible upsides, and they’re why serious labs are pursuing this beyond the marketing stunts. But it’s worth sitting with the fact that we’re now running experiments where nobody can rule out that something is happening on the other end of that noise.</p><p>So here’s my honest question for you, not a rhetorical one: if you found out tomorrow that a lab near you had scaled this up tenfold, would that change how you feel about the research, or does the size of the dish not actually matter to you? Tell me where your line is in the comments.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=0d90b4186d6a" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your AI Agent Can Call Any Tool on Your MCP Server.]]></title>
            <link>https://medium.com/@almohtadyg1/your-ai-agent-can-call-any-tool-on-your-mcp-server-067445fc1945?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/067445fc1945</guid>
            <category><![CDATA[least-privilege]]></category>
            <category><![CDATA[ai-agent-tools]]></category>
            <category><![CDATA[prompt-injection-attack]]></category>
            <category><![CDATA[mcp-security]]></category>
            <category><![CDATA[ai-agent-authorization]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Mon, 03 Aug 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-08-03T13:01:02.932Z</atom:updated>
            <content:encoded><![CDATA[<h4>I Built the Proxy That Says No.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*1I3Ikzvg8wzO95QE-Dp0CQ.png" /></figure><p>Most MCP setups hand an agent the entire toolbox the second it connects. Here’s the checkpoint I put in front of mine.</p><p>Three weeks ago I connected a plain filesystem MCP server to check what tools it actually exposed, and delete_file came back sitting right next to read_file. Same list. Same visibility. Same one-call distance from an agent that only ever needed to read a couple of notes.</p><p>Nobody warned me. Nothing asked first. That’s just how MCP servers work out of the box: connect, and you see everything the server is willing to hand you, whether your agent needs it or not.</p><p>That’s the moment I stopped trusting my own setup. If a destructive tool sits as casually in a tool list as a read-only one, the only thing standing between “helpful automation” and “wiped directory” is an agent never happening to reach for the wrong name. That’s not a security model. That’s luck, and I don’t build things on luck.</p><p>So I built a proxy that sits between the agent and the real server and actually enforces a line. By the end of this you’ll know exactly what’s missing from a default MCP setup, and here’s the promise: the fix isn’t a smarter agent, it’s a boundary the agent can’t argue its way around.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eXlOsI__Fco04FhpZIPfkg.png" /></figure><h3>The part almost nobody checks before wiring up an agent</h3><p>Here’s the thing about MCP that doesn’t get said enough. The protocol tells an agent what tools exist and how to call them. It says nothing about whether the agent <em>should</em> be allowed to call them. That decision gets left entirely to whoever built the server, and in practice, most servers just expose the whole toolbox and hope for the best.</p><p>Picture a real setup. You connect an agent to a filesystem server so it can help organize some notes. That server also happens to expose delete, move, and overwrite, because that’s just what a general-purpose filesystem server does. Your agent never needed any of those for the notes task. It has them anyway, sitting there, waiting.</p><p>Now drop a prompt injection into the mix. A poisoned file, a manipulated instruction buried in something the agent reads along the way. The agent doesn’t need to be tricked into doing something impossible. It just needs a nudge toward a tool that was sitting in plain sight the whole time. That’s the actual attack surface, and it’s wide open in a lot of MCP setups running in production right now.</p><p>I went looking for something that would sit in front of my server and actually hold that line. I found plenty of writing explaining this is a problem. I didn’t find much that just handed me a working proxy I could point at my own server and run today. So here’s what I ended up building, and here’s the part that changed how I think about the whole problem.</p><h3>What I actually built, in plain terms</h3><p>The idea is a security checkpoint, not a smarter agent. Before anyone connects, a separate offline step studies the real server exactly once. It connects, pulls the full list of tools, and writes down what each one does and how dangerous it looks. Reading a file gets tagged one way. Deleting one gets tagged completely differently. That inventory gets saved and locked in before any live agent ever touches the server.</p><p>Once that inventory exists, a proxy sits in front of the real server for every single request going forward. A tool that’s outright denied never shows up in the list the agent even sees, so there’s nothing to prompt-inject around, because there’s nothing there to ask for. A risky tool, anything that writes or changes state, gets held for a human to approve before it actually runs. A destructive tool gets blocked automatically, no matter how cleverly the surrounding request is worded.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/847/1*9ZdMMQgwa6cVXTxIynRfyQ.png" /></figure><p>Here’s the concrete before and after that actually convinced me this was worth shipping. Before: an agent connects straight to a filesystem server and sees four tools, read, write, delete, move, all flat, all equally callable, all one call away. After: that same agent connects through the proxy under a plain policy file that allows read, holds write for a human check, and simply never lists delete or move at all. Nothing changed about the agent. Everything changed about what it could reach.</p><p>Every decision the proxy makes, allowed, denied, or held for a human, gets written to a log, one line per decision. Not because I assumed I’d need it, but because the one time something actually goes sideways, you want a paper trail sitting there instead of a guess you make after the fact.</p><h3>The part that actually surprised me while building this</h3><p>I expected the hard part to be the policy engine, the actual rules about what’s allowed. It wasn’t. The hard part was realizing how much of “security” here is really just refusing to trust a snapshot. A tool’s description isn’t a fixed fact once you’ve verified it once. It’s a claim the server makes fresh every time an agent connects, and nothing stops that claim from quietly changing between one session and the next.</p><p>Here’s a case that made the point for me. Imagine a tool that starts out described as “reads a file’s contents.” Nothing scary there. Now imagine that same tool, weeks later, quietly redescribed as “reads a file’s contents and forwards them to a configured webhook.” Same name. Same signature. A completely different tool wearing the same trust you already gave it.</p><p>That’s why catching that kind of drift matters more than the access rules themselves, honestly. Access rules assume you already know what a tool does right now. Drift detection is what protects you from a tool quietly becoming something else after you’ve already decided to trust it. Most security thinking about agents focuses on the first problem. Almost none of it focuses on the second, and the second is the one that actually gets exploited.</p><p>I also learned, the annoying way, that a default-deny policy has to be enforced by the format itself, not just by good intentions. My first policy format let someone set the default action to “allow” if they really wanted to, just by typing it in. I killed that option completely. The schema itself now refuses to even load a policy file that tries it. If your safe default can be switched off with one careless line in a config file, it was never actually the default.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*btg4dZzApzglNcyXfbOZ3g.png" /></figure><h3>Where this leaves you if you’re wiring up an agent right now</h3><p>If you’ve connected an agent to an MCP server and never once pulled the full tool list to see what’s actually in there, you’ve got the same blind spot I had three weeks ago. Go check. Actually list it out. You’ll probably find at least one tool sitting in there your agent never needed for the job you built it to do.</p><p>The fix isn’t a smarter model watching itself more carefully. It’s a boundary the model can’t talk its way around, because the tool it would need was never visible to begin with. That’s a completely different guarantee than “the agent probably won’t misuse this,” and it’s the only kind I’d actually trust once real data is on the line.</p><p>So, what’s sitting in your MCP server’s tool list right now that your agent has genuinely never needed once? Drop it in the comments, I want to see what people find when they actually go look.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=067445fc1945" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Vercel’s Free Tier Stops Being Free the Exact Day Your Project Works]]></title>
            <link>https://medium.com/@almohtadyg1/vercels-free-tier-stops-being-free-the-exact-day-your-project-works-c8611e861388?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/c8611e861388</guid>
            <category><![CDATA[web-hosting-cost]]></category>
            <category><![CDATA[indie-hacker-tools]]></category>
            <category><![CDATA[side-project-deployment]]></category>
            <category><![CDATA[cloud-pricing]]></category>
            <category><![CDATA[jamstack]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Sun, 02 Aug 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-08-02T13:01:02.192Z</atom:updated>
            <content:encoded><![CDATA[<h4>The ten hosting platforms developers actually use in 2026, filtered by the one constraint that decides which one bites you</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*NteCfqJrxZChrGzSDPGKiw.png" /></figure><p>You build a side project on a Saturday. You deploy it to whatever platform your tutorial used. It sits there for free, quietly, for three months.</p><p>Then someone shares it. Traffic shows up. Maybe it starts making a little money from an affiliate link or a small subscription. And that’s the exact moment some of these platforms flip a switch you never read about, because it was buried under “unlimited bandwidth” in the marketing copy, not in the pricing table.</p><p>This isn’t a ranking of “best” hosts. Rankings assume everyone has the same project. You don’t. So here’s the actual filter: which of these ten platforms fits the specific way your project is going to grow, and which one is hiding a constraint that only shows up after you’ve already committed.</p><p>By the end you’ll know exactly which platform matches your situation, and which “obvious” pick has a catch nobody put in the comparison chart.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*Ymh2Ph4uSPOgCG_JN8i0eQ.png" /></figure><h3>The constraint that actually decides this, not the feature list</h3><p>Every hosting comparison lists bandwidth, build minutes, and price. Almost none of them lead with the thing that actually determines whether you’ll be happy in six months: is this a platform built for static, stateless deploys, or one built to keep a real backend process alive?</p><p>That single split explains most of the pros and cons below. Static-first platforms are cheap, fast, and generous, right up until your app needs something that stays running, like a scheduled job or a persistent database connection. Backend-first platforms cost real money from day one, but they don’t punish you for having a server.</p><p>Keep that split in mind. It’s the thing that decides which of these ten actually works for you, not the star rating.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*YdJlUCxpehgfIwp2iJQCGA.png" /></figure><h3>If you’re shipping a static site or a Next.js frontend</h3><p><strong>Vercel</strong> is still the best-integrated home for Next.js specifically, since the same company builds both. The Hobby plan gives you a workable free tier with a generous chunk of bandwidth and thousands of build minutes. The catch: that free tier explicitly bans commercial use. The moment your project earns money, displays ads, or exists for a business purpose, you’re required to move to the paid Pro plan, billed per team seat. That’s the “free tier stops being free” moment in the headline, and it’s the single most common surprise new indie developers report hitting.</p><p><strong>Netlify</strong> is the closest direct competitor and the safer pick if you think you might monetize early, since its free and paid tiers both permit commercial use. In 2026 Netlify moved to a credit-based pricing system, which is more flexible than a flat cap but takes a minute to actually understand, since bandwidth, build minutes, and function calls all draw from the same shared pool of credits.</p><p><strong>Cloudflare Pages</strong> currently has the most generous free tier of the three: unlimited bandwidth, no commercial-use restriction, and a large number of monthly builds. If your project is traffic-heavy and mostly static, this is usually the cheapest place to end up, though the tradeoff is a steeper learning curve once you go past simple static hosting into Cloudflare’s own Workers ecosystem for anything dynamic.</p><p><strong>GitHub Pages</strong> is the plainest option here: free, static-only, no server-side code, no database. It’s the right choice for a portfolio, documentation site, or a project page that will never need a backend, and the wrong choice the moment you need even a simple contact form that isn’t handled by a third-party embed.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*W8nQjifmnHWGsxxTrb8KZw.png" /></figure><h3>If your app needs a backend that actually stays running</h3><p>This is where the picture changes completely, because “free” gets a lot rarer.</p><p><strong>Railway</strong> is popular for full-stack apps that need a database sitting next to the app itself, with private networking between services and automatic environment variable wiring. It no longer offers an indefinitely free tier; new accounts get a starting usage credit, then it’s pay-for-what-you-use. That usage-based model tends to be cheaper than per-seat pricing once you have more than one or two people on the project.</p><p><strong>Render</strong> aims squarely at “Heroku, but modern.” It supports static sites, background workers, cron jobs, and managed Postgres on one platform, with genuinely predictable pricing. Its free web services do exist, but they spin down after a period of inactivity, so the tradeoff for going free is a cold start delay on the first request after idle time.</p><p><strong>Fly.io</strong> runs your app as small, fast-booting virtual machines spread across dozens of regions, which is the right pick if actual users in different countries need low latency. Its free allowance has shifted more than once over the past year depending on which source you check, so treat any specific free-tier number for Fly.io as something to confirm on their current pricing page rather than something to bank on.</p><p><strong>DigitalOcean App Platform</strong> sits in the middle: a small free allotment for static sites, and container-based apps starting at a low flat monthly rate once you need something that stays running. It’s the pick for developers who want Heroku-style simplicity now with a clear, unsurprising path up to DigitalOcean’s full infrastructure later, without switching providers.</p><h3>If you’re deploying Python specifically</h3><p><strong>PythonAnywhere</strong> still exists specifically to make hosting a Python script or a small Flask or Django app painless from directly inside a browser, no server configuration required. It genuinely is one of the fastest ways to get a Python web app live. But 2026 brought a real structural change worth knowing before you commit: the platform merged its two lowest paid tiers into a single Developer tier and reduced direct support on free accounts to community-based help only. The free tier still works, it’s just leaner than it used to be, and existing users who wanted to lock in the old lower price had a short window to do it before the new pricing took effect.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*KNzw7FRDN8-S6cn5kc1yaQ.png" /></figure><h3>The one everyone still recommends that you should think twice about</h3><p><strong>Heroku</strong> used to be the default answer to “how do I host my app,” and a lot of tutorials still say it. Two things changed that. Its free tier ended back in 2022, so it’s paid from day one now. And in February 2026, Heroku moved into what its own team calls “sustaining engineering mode,” meaning the platform stays stable and secure but isn’t getting meaningful new features, and it stopped signing new Enterprise contracts. It still runs real production apps and it isn’t disappearing overnight. But if you’re picking a platform for a project you expect to still be running in three or four years, building on something that has openly stopped evolving is worth pausing on.</p><h3>The before and after that actually matters</h3><p>Picture the exact same weekend project on two different timelines. Week one, it’s a free hobby deploy, zero cost, works fine. Week twelve, it gets picked up somewhere, starts pulling in a small amount of ad or affiliate revenue, and traffic triples.</p><p>On a platform with a commercial-use restriction on its free tier, that week-twelve version now technically requires an upgrade to a paid, per-seat plan, whether or not the revenue covers it yet. On a platform without that restriction, the exact same growth just means a slightly higher usage bill, scaled to what you’re actually using. Same project, same growth curve, completely different bill, and the difference was decided the day you picked a host, not the day you got popular.</p><p>That’s the actual decision hiding inside “top 10 hosting platforms” lists. Not which one has the nicest dashboard. Which one’s free tier was built for a hobby project that stays a hobby, and which one was built to grow with you without changing the rules underneath you.</p><p>So here’s the honest question: which constraint on this list have you already hit without realizing it was the platform’s fault and not yours? Drop it in the comments, I’m genuinely curious which one bites people most.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c8611e861388" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Claude Code Never Touches a Single File.]]></title>
            <link>https://medium.com/@almohtadyg1/claude-code-never-touches-a-single-file-eb871d7da8ea?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/eb871d7da8ea</guid>
            <category><![CDATA[ai-agent]]></category>
            <category><![CDATA[ai-agent-architecture]]></category>
            <category><![CDATA[developer-tools]]></category>
            <category><![CDATA[system-design-concepts]]></category>
            <category><![CDATA[claude-code]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Sat, 01 Aug 2026 13:01:02 GMT</pubDate>
            <atom:updated>2026-08-01T13:01:02.226Z</atom:updated>
            <content:encoded><![CDATA[<h4>Here’s What Actually Does.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*WhPrGDGajck8JSmJRL7S-w.png" /></figure><p>You ask Claude Code to fix a bug. It reads three files, edits one, runs your tests, and tells you it’s done. It feels like the model just walked into your codebase and fixed it.</p><p>It didn’t. The model never opened a single file. It never ran a single test. It doesn’t have hands, and it doesn’t have access to your disk. Something else did all of that, and understanding what that something is changes how you debug this tool the next time it does something you didn’t expect.</p><p>Here’s the actual chain of events, piece by piece, so the next time Claude Code stalls, asks for permission out of nowhere, or “forgets” something from ten minutes ago, you’ll know exactly why.</p><h3>The thing predicting text has no hands</h3><p>Strip away everything else and a large language model does one job: it predicts the next chunk of text. Feed it “my favorite programming language is” and it’ll guess a plausible next word. Feed it a bug report and a pile of code, and it’ll guess a plausible next block of text too — the difference is just how complicated that guess can get.</p><p>Two things fall out of that. First, the model doesn’t remember anything between separate conversations. If you close a session and open a new one, nothing carries over unless you explicitly hand it back. Second, the model only knows what’s actually sitting in front of it right now, called the context window. Nothing outside that window exists to it, no matter how important it is.</p><p>So if the model can’t act and can’t remember, how does Claude Code feel like it’s doing both? That’s the whole rest of this article.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h8ex4VYdGv42qREXeK7zpw.png" /></figure><h3>The trick is that the model asks, and something else does</h3><p>When the model decides a file needs editing, it doesn’t edit anything. It writes out a specific, structured piece of text that essentially says: <em>I want to call the write-file tool, on this path, with this content.</em> That’s still just predicted text. It looks something like this, simplified:</p><pre>type: tool_call<br>tool: write_file<br>args: { path: &quot;app.py&quot;, content: &quot;...&quot; }</pre><p>A separate piece of software, the agent harness, is watching everything the model outputs. When it sees that structured request, it parses it, actually runs the write_file function on your real filesystem, and takes whatever comes back, success or an error, and stuffs it back into the model’s context. Then the model predicts again, now with the result of its own request sitting in front of it.</p><p>That’s the entire loop. Predict, request a tool, harness executes it, result goes back in, predict again. A task that looks like one smooth action from your side might be the model doing this fifteen or twenty times in a row before it ever shows you a sentence of text.</p><p>This also explains something that trips people up constantly: the model can’t override a permission prompt. When Claude Code asks “allow this command?”, that check lives entirely in the harness, not the model. The model can ask for anything it wants. Whether it’s allowed to actually happen is a decision made by ordinary software sitting between the model and your machine, checking the request against a rules list before anything runs.</p><p>That covers one tool call. But it still doesn’t explain how the tool loses track of something you told it five minutes ago, or how it can answer questions about files it’s never been shown. That’s next.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*eu1GLlCe9AlLapQcFJLp7g.png" /></figure><h3>Memory is a file, not a feature</h3><p>When people say the model “remembers your project,” what’s actually happening is duller and more useful to understand. Somewhere in your project there’s a memory file, commonly something like a CLAUDE.md, that gets read and dropped straight into the context window at the start of a session. The model isn’t remembering it. It’s reading it fresh, every time, exactly like it’s reading any other file you handed it.</p><p>Bigger projects extend this with a memory folder holding several files, loaded only when something in the conversation makes them relevant, plus skill files, which are just instructions for handling a specific kind of task, pulled in on demand instead of stuffed into every single prompt.</p><p>Here’s the concrete before-and-after. Ask an agent with no memory file “what are my coding preferences,” and it has nothing to draw on except whatever you’ve said in the current chat. Ask the same question with a preferences file sitting in the project, and the harness reads that file, drops its contents into context, and now the model can answer accurately, not because it recalled anything, but because the actual text of that file is sitting in front of it at that exact moment.</p><p>Clear the conversation and the effect vanishes instantly, even with the memory file still on disk, if the harness didn’t reload it. That’s the tell. If Claude Code “forgets” something you told it, the honest question isn’t “why doesn’t it remember,” it’s “did that information ever actually get written down anywhere, and did the harness load it back in this time.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*PurNIeSEPOi9gdCgrqM0lw.png" /></figure><p>Put together, everything the model sees in a single turn (system instructions, the tools it’s allowed to call, memory files, skill definitions, the whole conversation so far, and the results of every tool call made along the way) is called the context window. On a big task, most of that window fills up with conversation history and tool results, not with your original request. And that fill-up rate matters more than people expect, which is the last piece.</p><h3>More tools doesn’t mean more capable</h3><p>Every tool Claude Code can call gets described to the model up front, essentially as a menu: here’s the tool’s name, what it does, and exactly what arguments it expects. The model picks off that menu when it wants to act.</p><p>The problem is that a longer menu doesn’t make better decisions easier. It makes them harder. A model choosing between five clearly-scoped tools picks the right one almost every time. The same model choosing between forty overlapping tools starts guessing wrong more often, calling something adjacent to what it actually needed, or missing an obviously correct tool because it’s buried in a list of vaguely similar ones. If you’ve connected a pile of extra integrations to Claude Code and noticed it got clumsier instead of more capable, this is very likely why. Every added tool is added surface area for a wrong guess, not free extra ability.</p><p>This is also why a hard cap on tool calls per turn exists in most agent harnesses, usually somewhere around twenty or thirty. Without one, a model that’s slightly confused can loop on the same failed approach indefinitely, since nothing about predicting text stops it from predicting the same kind of mistake twice.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*VcxYjs3KdDAu5lP-YXyWMQ.png" /></figure><h3>What to actually check next time it’s acting strange</h3><p>Next time Claude Code does something that doesn’t make sense, skip the instinct to treat it like a black box having a bad day. Ask four boring questions instead: What’s actually sitting in the context window right now? Is the fact it “should know” written down anywhere the harness would reload? How many tools are currently connected, and could two of them plausibly overlap? And is the strange behavior a bad guess from the model, or a rule enforced by the harness that has nothing to do with the model’s judgment at all?</p><p>Once you’re asking those four questions instead of “why is the AI confused,” debugging this tool stops being guesswork. It’s the same as debugging any other piece of software built out of a loop, some state, and a set of rules, because that’s all it actually is underneath.</p><p>Have you hit a specific moment where Claude Code did something that only makes sense once you know it’s a loop, not a mind? Drop it in the comments, I’ll go through a few of the more interesting ones in a follow-up.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=eb871d7da8ea" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The Real Reason HTML Isn’t a Programming Language (And Why the Insult Doesn’t Land)]]></title>
            <link>https://medium.com/@almohtadyg1/the-real-reason-html-isnt-a-programming-language-and-why-the-insult-doesn-t-land-c9e143559561?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/c9e143559561</guid>
            <category><![CDATA[frontend-development]]></category>
            <category><![CDATA[html]]></category>
            <category><![CDATA[web-development]]></category>
            <category><![CDATA[tech-twitter]]></category>
            <category><![CDATA[junior-developer]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Fri, 31 Jul 2026 13:01:01 GMT</pubDate>
            <atom:updated>2026-07-31T13:01:01.936Z</atom:updated>
            <content:encoded><![CDATA[<h4>The technical line is real. The shame you’re supposed to feel about it isn’t.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4Goizu2VJG7jbIArDUtEEg.png" /></figure><p>A tweet made the rounds this week mocking someone who’d listed HTML at the very top of their tech stack graphic. The reply was short, brutal, and got thousands of likes, because everyone loves a good “well actually” moment on their timeline. The joke worked because it’s technically true. HTML isn’t a programming language.</p><iframe src="https://cdn.embedly.com/widgets/media.html?type=text%2Fhtml&amp;key=a19fcc184b9711e1b4764040d3dc5c07&amp;schema=twitter&amp;url=https%3A//x.com/Automateby_Priy/status/2082024314417934810&amp;image=https%3A//i.embed.ly/1/image%3Furl%3Dhttps%253A%252F%252Fpbs.twimg.com%252Fmedia%252FHOTWE0WbAAAVK2-.jpg%253Alarge%26key%3Da19fcc184b9711e1b4764040d3dc5c07" width="500" height="281" frameborder="0" scrolling="no"><a href="https://medium.com/media/d871ffa7895977a03764e004bd669b01/href">https://medium.com/media/d871ffa7895977a03764e004bd669b01/href</a></iframe><p>That’s not an opinion. It’s a definition, and definitions don’t care about feelings.</p><p>But here’s what the tweet and every quote-tweet under it got wrong: the reason HTML isn’t a programming language has nothing to do with how hard it is to learn, how much it matters day to day, or whether you deserve to call yourself a developer. It’s a narrow, specific, almost boring technical distinction. By the end of this you’ll know exactly where that line sits, why CSS sits in a genuinely weird gray zone most people arguing about this don’t even know exists, and how to talk about your own stack without flinching the next time someone tries this move on you.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*pf8ugw0SqCJptJ0NYcs5BQ.png" /></figure><h3>What Actually Makes Something a Programming Language</h3><p>Here’s the actual test, stripped of gatekeeping. A programming language lets you describe a process: do this, then check that, and if it’s true, do this other thing, and repeat until some condition changes. Variables that hold values. Conditionals that branch based on those values. Loops that repeat. Put those three together and you can, in theory, compute anything a computer is capable of computing. That property has a name, Turing completeness, and it’s the actual bar.</p><p>HTML doesn’t clear that bar, and it was never trying to. Open any HTML file and you’re looking at a tree of elements, a paragraph inside a div inside a section. There’s no way to write “repeat this list item ten times” or “only show this button if the user is logged in” using HTML alone. You can describe ten list items by literally typing them out ten times, but you can’t tell HTML to generate them based on a condition. It has no concept of a condition.</p><p>Compare that to five lines of JavaScript doing the same job:</p><pre>for (let i = 0; i &lt; items.length; i++) {<br>  if (items[i].inStock) {<br>    renderListItem(items[i]);<br>  }<br>}</pre><p>That loop, that if statement, that ability to check a value and change behavior based on it, is the entire difference. JavaScript can compute. HTML can only describe. That’s the whole distinction the tweet was gesturing at, minus the smugness.</p><h3>Where HTML Actually Sits</h3><p>The technical term for what HTML is happens to be right there in the name. It’s a markup language. Markup describes structure and meaning: this is a heading, this is a paragraph, this is a list, this image goes here. It’s declarative, meaning you state what you want to exist, not the steps to build it.</p><p>Programming languages are usually imperative, or at least capable of imperative logic: they describe a sequence of instructions a machine executes to arrive at a result. CSS lives in a similar declarative space to HTML, describing what things should look like rather than the steps to make them look that way. Neither one is telling the computer to do anything in a step by step sense. Both are telling it what state to render.</p><p>That’s genuinely the whole distinction. HTML and CSS describe. Programming languages compute. A markup language can be enormously expressive, deeply technical, and genuinely hard to master at a professional level, while still not being the thing that computes. Those two facts aren’t in tension. People just talk like they are.</p><p>Before you write off markup as the “easy” layer, though, there’s a wrinkle almost nobody brings up when they’re dunking on HTML.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*OksbhCJNs8lpMigdM5TcLA.png" /></figure><h3>The CSS Plot Twist Nobody Mentions</h3><p>CSS, the styling language sitting right next to HTML in every gatekeeping meme, has actually been shown to be Turing complete under specific, deliberately engineered conditions. Researchers have built things like functioning Rule 110 cellular automatons and even basic game logic using nothing but CSS selectors, checkbox hacks, and animation timing tricks, exploiting the way certain CSS features interact to simulate state changes and conditional behavior.</p><p>It’s a party trick, not a practical use case. Nobody’s shipping production logic in a stylesheet, and the browser environment around CSS is still doing real computation to make any of it work. But it’s a fun detail that undercuts the whole “markup bad, programming good” hierarchy people love to draw with a straight face. The line between “just styling” and “real computation” is blurrier than a two second dunk tweet has room to admit.</p><p>HTML doesn’t get that same loophole. There’s no checkbox hack that makes raw HTML Turing complete on its own, which is exactly why it’s the one that ends up as the punchline instead of CSS.</p><h3>Why This Barely Matters for the Job You’re Actually Trying to Get</h3><p>None of this taxonomy shows up anywhere in a hiring decision. Nobody on an interview panel is quietly docking points because your stack graphic listed a markup language next to a programming language. What they’re actually evaluating is whether you can take a design, build the interface, wire it to real data, and debug it when it breaks in a browser nobody tested against.</p><p>Here’s the before and after that actually matters, and it has nothing to do with terminology.</p><p>Before: “Skills: HTML, CSS, JavaScript, React, Python.” That’s a flat list. It tells a hiring manager nothing about what you can actually do with any of it, and it’s the exact format that invites someone to nitpick the first two words.</p><p>After: “Built and shipped three production interfaces from Figma designs to responsive, accessible HTML and CSS, then wired them to live data with JavaScript and React.” Same underlying skill set, completely different read. Nobody’s mentally filing that under “just HTML” because it’s describing a capability, not a vocabulary list.</p><p>The fix was never learning a rebuttal for pedantic tweets. It was describing what you build instead of naming the tools you build it with.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*4imfy2xfNh3tp4qolgh75Q.png" /></figure><h3>How to Actually Handle This the Next Time It Comes Up</h3><p>If this happens in an interview instead of your replies, the move is the same one that works in the reply guys’ favor when they’re not busy being smug: know the actual definition cold, then immediately pivot to what you build.</p><p>Something like: “You’re right that HTML and CSS are markup and styling, not computation, that’s an accurate distinction. What I actually bring is turning a design into a working, accessible interface and then making it interactive with JavaScript, which is where the real logic lives.” That sentence does two things at once. It shows you understand the technical line better than the person trying to use it against you, and it moves the conversation to the part of your work that was never in question.</p><p>Gatekeeping about this specific distinction usually comes from people who learned the definition once and never learned what to do with it besides feel superior on a Tuesday. You now know it better than they do, and you know it doesn’t mean what they think it means.</p><p>So here’s my actual question for you: what’s the most confidently wrong thing someone’s said to you about your stack, HTML gatekeeping or otherwise? Drop it in the comments, I want to see how creative people get.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=c9e143559561" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Everyone’s Panicking About Substack’s AI Detector.]]></title>
            <link>https://medium.com/@almohtadyg1/everyones-panicking-about-substack-s-ai-detector-1bb8a4232623?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/1bb8a4232623</guid>
            <category><![CDATA[substack]]></category>
            <category><![CDATA[media-literacy]]></category>
            <category><![CDATA[ai-detection]]></category>
            <category><![CDATA[writing-on-medium]]></category>
            <category><![CDATA[content-moderation]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Thu, 30 Jul 2026 13:01:01 GMT</pubDate>
            <atom:updated>2026-07-30T13:01:01.871Z</atom:updated>
            <content:encoded><![CDATA[<h4>Medium’s CEO Just Pointed Out the Actual Problem.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_r5ceVFtXUc8yooXwHkM9A.png" /></figure><p>Ruben Hassid took a post that scored 100% AI-generated on Substack’s new detector, changed a single character, and ran it again. The score flipped to 100% human.</p><p>Not a rewrite. Not a new paragraph. One character.</p><p>If that makes your stomach drop a little, this is for you. On July 21, Substack quietly connected an AI-detection tool called Pangram to every post, note, and comment over 100 words on the platform. Readers can now hit a button and get a percentage score for how human your writing is. Then, on July 27, Medium’s own CEO published a public takedown of the whole approach. His complaint wasn’t the one you’d expect.</p><p>Here’s what actually shipped, why the detector breaks the way it does, and what it changes about how you should be writing this week.</p><h3>What Substack Actually Built</h3><p>Substack CEO Chris Best introduced the feature in a post he titled “Against Claudefishing.” His term, not mine. He defined it as the gap between what a reader assumes, that a person wrote this, and what actually happened, nobody did, and no human thought went into it. Best has also framed the bigger motive plainly: he doesn’t want Substack turning into the kind of platform people mock LinkedIn for, flooded with generic, AI-flavored posts nobody asked for.</p><p>The mechanics matter more than the framing. The scan only works on text longer than 100 words, and only on content published from July 21, 2026 onward. Your entire back catalog is untouched. It runs on web and iOS, with Android support still coming. If a post sits behind a paywall, only paid subscribers can run the scan, not free readers browsing the preview.</p><p>Substack also added two release valves. You can write a “How I make this” statement that explains your process up front, and you can disable the scan entirely on any individual post. Report a wrong result and Substack says it’ll look into it.</p><p>That’s the calm version. It’s not the version that spread.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*lcipup8wHYLQrtR9JP8UZg.png" /></figure><h3>The One Character That Broke It</h3><p>Within days, writers were testing the tool on their own archives and comparing notes, and the results were messy in both directions.</p><p>Hassid’s single-character flip is the clearest demonstration that the score isn’t measuring what people think it’s measuring. It’s not reading meaning. It’s reading statistical texture, and a tiny nudge to that texture is enough to flip the verdict entirely.</p><p>The reverse case is just as telling. One newsletter writer ran a post she’d written with heavy AI assistance, drafting help and editing included, through the scanner expecting a high AI score. It came back 100% human. Her explanation was straightforward: the ideas, the structure, and the final sentences were hers, and the tool has no way to see any of that. It only sees the finished text.</p><p>Put those two results side by side and you get an uncomfortable picture. A fully human post can score as fully AI. A heavily AI-assisted post can score as fully human. The detector isn’t just unreliable at the edges. It’s shaky at the core of what it claims to measure.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*ugPuMQCInaOCHp8_aUhtIQ.png" /></figure><h3>Medium’s CEO Didn’t Say What You’d Expect</h3><p>Six days after launch, Tony Stubblebine, CEO of Medium, a direct competitor to Substack, published his own response. He didn’t lead with “detectors are inaccurate,” even though he agrees with that. He led with something sharper: Medium and Pangram already have history, and it isn’t good.</p><p>Stubblebine says he watched Pangram’s own founder publicly call out a specific Medium writer as fully AI-generated, in a case Stubblebine says he personally knows wasn’t. If the company building the detector can’t get that call right in public, the tool has a bigger problem than edge cases.</p><p>Then he went further, describing what he sees as a built-in conflict of interest in Pangram’s business model. According to Stubblebine, Pangram runs unsolicited scans on companies before those companies are even customers, hands the results to press outlets as a story, and then pitches its detection service to that same company afterward. He named Wired specifically as an outlet he believes got used this way. Medium, he says, already knew it had an AI-slop problem. What he objects to is Pangram, in his telling, hijacking that story and reframing it as a volume problem instead of a recommendation problem, which happens to be exactly the problem Pangram sells a fix for.</p><p>Worth being clear about what this is: one CEO’s public accusation against a vendor his competitor just adopted. Take it as a serious allegation worth watching, not a settled verdict. But notice what he’s actually arguing, because it’s a different complaint than “the detector is imperfect.” It’s “the company selling the detector benefits every time the detector looks scarier than it is.”</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*0E7lCpDmHIAj4Efqn0quLw.png" /></figure><h3>Does a Broken Signal Beat No Signal?</h3><p>Here’s the tension underneath all of this that’s easy to skip past. Substack and Medium are both responding to something real. Readers genuinely can’t always tell what they’re spending their attention on anymore, and that’s not a manufactured panic.</p><p>Substack’s answer is to hand readers a number. Medium’s public position, including in Stubblebine’s own posts about the platform, leans the opposite way: most of what shows up in a Medium reader’s feed is there because a human editor, a publication, or someone in their network vouched for it, not because a model scored it. Medium is betting that human judgment scales better than a percentage a single character can flip.</p><p>Neither approach is obviously right. A wrong number stated with confidence can do more damage to a real writer than having no number at all, because it looks like proof instead of a guess. That’s the actual stakes of this fight, not just “which platform is nicer to AI-assisted writers.”</p><h3>Why This Keeps Happening</h3><p>Strip away the platform rivalry and there’s a structural reason detectors fail this particular way, and it’s worth understanding if you’re going to keep publishing.</p><p>An AI detector doesn’t read for intent. It reads for statistical pattern: things like sentence length variation, word predictability, and rhythm. Real human writing has a lot of natural variation in those patterns. So does AI writing that’s been run through a “humanizer” tool built specifically to scramble those patterns and slide past detection. Pangram’s own CEO has put the tool’s false positive rate at roughly one in ten thousand, worth noting that’s the vendor’s own figure, not an independently audited one, and critics point out that the false positives that do happen cluster on specific groups: non-native English speakers and neurodivergent writers, whose natural rhythm can look more uniform, or more unusual, to a model trained on an average.</p><p>That produces a lopsided outcome. Writers deliberately trying to disguise AI text already have tools built to beat the detector. Writers with nothing to hide, who just happen to write in a rhythm the model doesn’t expect, are the ones left holding a false accusation. The detector ends up filtering for statistical conformity, not honesty.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*UNVP5twtay_IIZJRskujcw.png" /></figure><h3>What Actually Changes For You</h3><p>None of this means ignore the story. It means aim your response at the right target.</p><p>Don’t rewrite your natural voice to flatter a probability score. If your sentences are short and blunt, or long and winding, or your English carries the shape of a second language, that’s not a defect to sand down because a tool might misread it. Sanding it down is exactly the outcome Stubblebine is warning about: writers quietly changing their own writing to please a detector, which makes the writing worse and the detector no more accurate.</p><p>If you publish on Substack, know the actual boundaries of the tool before you panic about it. It doesn’t touch anything published before July 21. It doesn’t scan under 100 words. Free readers can’t scan your paywalled work. You can turn it off per post, and you can write your own disclosure instead of letting a percentage speak for you.</p><p>If you use AI anywhere in your process, drafting, editing, research, keep a record of it. Save your prompts, keep an early draft, note what you changed by hand. Not because you owe anyone a confession, but because “here’s my actual process” beats “trust me” if a wrong score ever gets thrown at you in public.</p><p>And regardless of which platform you’re on, the actual currency was never a detector score. It’s whether the specific people reading you trust that you’re the one who wrote it. A tool that can be flipped by one character was never going to be the thing that decides that.</p><p>Did the detector ever ping something you wrote, or did you go check your own archive after reading this? Drop it in the responses. I’m curious how many real false positives are actually out there versus how many people are just braced for one.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=1bb8a4232623" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Your GPU Isn’t Too Weak. You Downloaded the Wrong File.]]></title>
            <link>https://medium.com/@almohtadyg1/your-gpu-isnt-too-weak-you-downloaded-the-wrong-file-978dd98f3622?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/978dd98f3622</guid>
            <category><![CDATA[open-weight-model]]></category>
            <category><![CDATA[llm-inference]]></category>
            <category><![CDATA[local-llm]]></category>
            <category><![CDATA[model-quantization]]></category>
            <category><![CDATA[gpu]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Wed, 29 Jul 2026 13:01:04 GMT</pubDate>
            <atom:updated>2026-07-29T13:01:04.758Z</atom:updated>
            <content:encoded><![CDATA[<h4>The “out of memory” error wasn’t about your hardware. It was about a decision someone else made before you ever hit download.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*jlXsX5s2cggsIIeRANTNeQ.png" /></figure><p>You finally get a good open-weight model to try locally. You’ve got a decent GPU, nothing crazy, but enough to run games at high settings. You hit download, load it up, and get hit with an out-of-memory error before the model even finishes loading.</p><p>The instinct is to blame the card. Maybe you need to upgrade. Maybe local AI just isn’t for people without a server rack in their closet.</p><p>That instinct is wrong, and it’s why people end up paying for cloud GPU rentals they never actually needed. The model you downloaded was almost certainly the full-precision version, the one built for a data center GPU with ten times your VRAM. There’s usually another version of that exact same model sitting one click away that runs fine on what you already own.</p><p>By the end of this, you’ll know exactly what that other version is, why it exists, and how to pick the right one instead of guessing. Here’s the part nobody explains before you hit that error: the model isn’t one fixed thing. It’s a set of numbers, and someone can choose how precisely those numbers get stored.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*h9e5MTZyWZkZQfhXmyJZPg.png" /></figure><h3>What’s actually sitting in that file</h3><p>Every weight inside a neural network is just a number. Multiply this input by that number, add it to another number, pass it along. A large language model might have tens of billions of these numbers, called parameters, and by default, each one is often stored as a 32-bit or 16-bit floating point value.</p><p>That precision costs space. A model with 70 billion parameters, stored at full 16-bit precision, needs roughly 140GB of memory just to hold the weights, before you’ve generated a single token. Some versions ship at 32-bit, which doubles that again to around 280GB. Consumer GPUs top out nowhere near that. Even a strong workstation card is measured in tens of gigabytes, not hundreds.</p><p>Quantization is the fix, and the idea is almost embarrassingly simple once you see it: store each number with fewer bits. Instead of 16 bits of precision per weight, use 8, or 4, or in some experimental cases even less. Fewer bits per number means the whole model takes up a fraction of the space.</p><p>Here’s the number that actually matters to you: that same 70-billion-parameter model, quantized down to 4 bits, shrinks to somewhere around 35 to 40GB. That’s not a modest improvement. That’s the difference between “needs a data center” and “runs on a single high-end consumer card, or splits across two.”</p><p>But shrinking the numbers isn’t free. Something has to give. The open question, the one that decided which quantization method won out, was how to lose precision without losing the model’s actual behavior.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*_2saOIK3Oc371p4T-IIwLw.png" /></figure><h3>Rounding badly breaks things. Rounding carefully doesn’t.</h3><p>The laziest way to quantize a model is to just round every number to the nearest value the smaller bit width can represent. This is called naive rounding, and it works, technically. The model gets smaller. It also gets noticeably worse, sometimes badly enough to make it useless, because rounding treats every weight as equally important. It isn’t.</p><p>In any trained network, some weights carry way more influence over the output than others. Round an unimportant weight sloppily and nothing happens. Round an important one the same way and the model starts producing garbage.</p><p>This is the actual engineering problem quantization research spent the last few years solving: how do you find out which weights matter before you round them, so you can protect the ones that count and round the rest more aggressively?</p><p>Two different answers to that question became the dominant approaches you’ll actually run into. One approach runs the model against a small calibration dataset and mathematically works out, layer by layer, exactly how much error each rounding choice would introduce. It then adjusts the remaining weights in that layer to cancel out as much of that error as possible before moving on. It’s slow to prepare but produces a compact, accurate result.</p><p>The other approach takes a shortcut based on a real observation: a small slice of weights, often under one percent of the total, get multiplied by unusually large activation values during inference. Those specific weights do the most damage if rounded carelessly. Instead of correcting every layer mathematically, this approach identifies that small slice ahead of time, scales and protects it, then rounds the rest of the model more freely. It’s faster to run and usually easier to slot into an existing workflow.</p><p>Neither of these happened by accident, and neither is the only method out there. There’s a whole family of newer techniques stacked on top of both ideas, aimed at specific failure modes like the outlier activation spikes that show up in very large models. That part of the story is still being actively rewritten, which matters for a decision you’ll make in a minute: picking a file off a download page.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*v2jodXTxsNEiMI8DE8SVug.png" /></figure><h3>What you’ll actually see when you go looking</h3><p>Here’s where the theory turns into an actual decision you have to make, because none of what’s above shows up labeled with any of that language on a download page. Instead, you’ll see file names and extensions.</p><p>One common format packages a quantized model into a single portable file designed to run efficiently on regular consumer hardware, including plain CPUs, which matters if you don’t even have a dedicated GPU. Another format is built specifically for fast GPU inference and tends to need a bit more setup but rewards you with speed if you’ve got the hardware for it. A third takes the “protect the important weights” approach described above and is often the best pick when you want to stay close to the original model’s quality at a low bit width.</p><p>None of these is universally “the best.” The right pick depends on what you’re running it on, not on which one sounds more advanced. If you’ve only got a CPU or a modest GPU and want the path of least resistance, the portable single-file option is usually it. If you’ve got a capable GPU and want maximum speed, the GPU-native formats pull ahead. If quality retention matters more to you than raw speed, look for whichever format explicitly advertises activation-aware or calibration-based quantization in its description.</p><h3>The tradeoff nobody puts in the headline</h3><p>Quantization is not a free win, and any explainer that makes it sound like one is skipping the part that actually matters for your decision. Push the bit width down far enough, especially below 4 bits, and you start losing real capability. Reasoning gets shakier, and long, complex instructions start getting dropped or misread.</p><p>The model doesn’t fail loudly when this happens. It just gets quietly worse in ways that are easy to miss if you’re not testing carefully.</p><p>The sweet spot for most people running models locally right now sits at 4-bit, sometimes 8-bit if you’ve got the memory to spare and want to stay closer to the original behavior. Going lower than 4-bit is possible and sometimes necessary if your hardware can’t fit anything bigger, but it’s worth treating as a last resort, not a default.</p><p>There’s also a second, quieter form of quantization worth knowing about, one that happens during training instead of after it. Instead of training a full-precision model and shrinking it afterward, this approach trains the model to already expect and compensate for lower precision from the start. It tends to hold up better at very low bit widths, at the cost of needing much more compute up front, which is why the vast majority of models you’ll download were quantized after training rather than during it.</p><h3>Why this is worth understanding instead of ignoring</h3><p>Open-weight models keep getting released at sizes that used to require serious institutional hardware to even load, and quantization is the entire reason a hobbyist with one GPU can run any of them at all. It’s not a workaround or a compromise you’re forced to accept. It’s the specific piece of engineering that decides whether “open-weight” actually means “open to you,” or just “open to whoever has a server budget.”</p><p>Next time you’re staring at a model page with five different download options and no explanation of what any of them mean, you’ll know you’re not choosing between five random files. You’re choosing how much precision you’re trading for how much room to actually run the thing.</p><p>What’s the biggest model you’ve managed to get running on your own hardware, and what did you have to give up to make it fit? Drop it in the comments, I’m genuinely curious how far people are pushing consumer setups right now.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=978dd98f3622" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[The One File Nobody Tells You to Build Before You Prompt ChatGPT]]></title>
            <link>https://medium.com/@almohtadyg1/the-one-file-nobody-tells-you-to-build-before-you-prompt-chatgpt-38cbacf479b7?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/38cbacf479b7</guid>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[self-improvement]]></category>
            <category><![CDATA[chatgpt]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[productivity]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Tue, 28 Jul 2026 13:01:05 GMT</pubDate>
            <atom:updated>2026-07-28T13:01:05.489Z</atom:updated>
            <content:encoded><![CDATA[<h4>Everyone treats AI like a search bar. The people getting real output built something first.</h4><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*7vi8EZ4sOLX3YYXUQS7LWQ.png" /></figure><p>Open a fresh ChatGPT tab right now and ask it anything real, and it’ll answer like a stranger giving advice to someone it’s never met. Because that’s exactly what’s happening. You’re not getting a bad model. You’re getting a generic one, because you gave it a generic amount of information to work with.</p><p>Here’s the part nobody says out loud: every time you open a new chat and type a question cold, you’re asking a stranger for advice with zero context about who you are, what you’re trying to build, or what “good” even looks like to you. Of course the answer is forgettable. It has nothing to be specific to.</p><p>By the end of this, you’ll have a document that fixes that permanently, and you’ll never write a cold prompt again.</p><h3>Four missing words are the whole problem</h3><p>Before the fix, the basics. Every prompt that actually works has four parts, and skipping any one of them is why your results feel flat.</p><p><strong>Role.</strong> Tell it who to be. “Act like a senior copywriter” or “act like a skeptical CFO” tells the model which body of knowledge to pull from, instead of averaging across everything it knows.</p><p><strong>Context.</strong> Give it your actual situation, not “write me a bio,” but who you are and what you’ve already tried. Vague input produces vague output, every time.</p><p><strong>Command.</strong> Say exactly what you need, not a vibe. “Make it better” is not an instruction. “Cut this to 150 words and open with the number, not the setup” is.</p><p><strong>Format.</strong> Tell it the shape you want the answer in, bullet points, a table, a five-sentence paragraph, whatever you’ll actually use.</p><p>Get those four right and your prompts stop being coin flips. But none of them matter if you’re retyping them from scratch every single time, which is what almost everyone does.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*2Zs9GuQYXHRr5h7-c5i_GQ.png" /></figure><h3>The document that ends cold prompting for good</h3><p>If ChatGPT sounds like a stranger, it’s because you’ve never properly introduced yourself to it. A master prompt fixes that. It’s one document with everything relevant about you, and you attach it at the start of a conversation instead of re-explaining your life every time.</p><p>Building it is a three-step conversation, not a writing project. First, tell the AI to interview you: “Act as an interviewer and ask me everything you’d need to build a master prompt for my role.” It comes back with questions you’d never have thought to answer on your own.</p><p>Second, answer them with real detail. If typing feels slow, use voice-to-text and talk through it out loud, rambling here is a feature, not a flaw. Third, say: “Generate a master prompt from this and save it as a document.” Now you have a portable file you can attach to any model, any platform, even ones that don’t exist yet.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*3vGnT4ul2oiB2G_KB9SUOQ.png" /></figure><p>Here’s what that actually looks like in practice. Ask a cold ChatGPT “give me feedback on my pricing,” and you get a generic paragraph about value-based pricing that could apply to any business on earth. Ask the same question with a master prompt attached that says you’re a freelance editor charging per project, burned out from underpricing, allergic to hourly billing, and the answer changes shape entirely, it references your actual constraints, disagrees with a number you’d have picked, and tells you why. Same model. Same question. Completely different judgment, because now it has something to be specific about.</p><h3>Stop accepting the first draft</h3><p>Context solves the generic-stranger problem. It doesn’t solve the good-enough problem, the other reason AI output feels forgettable: most people stop at the first response.</p><p>Fight for the output the way you’d edit your own first draft. When something’s off, don’t say “make it punchier,” that tells the model nothing. Say what punchier means to you specifically: open with the claim, not the setup, cut every sentence that hedges. Specific feedback in, specific improvement out.</p><p>If you’re iterating on something with a repeatable structure, like an email template, ask for it as an editable document instead of a fresh rewrite every pass. You end up tweaking one version instead of getting a slightly different generation each time, which is where most people quietly lose an hour without noticing.</p><h3>Turn your best output into a rule you never repeat</h3><p>Once you’ve iterated something until it actually sounds like you, don’t let that work die in one chat window. Take the final version and ask: “Write the instructions that would have generated this exact output.” What comes back is a system prompt, reusable behavior rules instead of a one-time answer.</p><p>Save that as its own document. It travels the same way the master prompt does, across models and platforms, and if your tool supports custom assistants, you can turn it into one your whole team reuses without ever seeing the underlying prompt.</p><p>The pattern by now: master prompt tells the AI who you are. System prompt tells it how to behave. Once, not every time.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/1*nA7vqaCfbUofqRRDSPHTaQ.png" /></figure><h3>The skill nobody uses on purpose</h3><p>Here’s what keeps people at a mediocre plateau even after doing everything above. Most models are built to agree with you. Only ever ask it to help, and you get a polished mirror of what you already believed walking in.</p><p>Tell it to push back instead. Put “act as a devil’s advocate” directly in your prompt, and ask it to stress-test your assumption and list what could go wrong before it helps you execute. Then ask it to break its own criticism down to first principles, the reasoning underneath the objection, not just the objection itself.</p><p>If you agree with what it pushes back with, don’t just accept it and move on. Add it to your master prompt. Now every future answer already accounts for that blind spot, permanently, instead of you rediscovering it every few months.</p><h3>Where this actually lands</h3><p>None of this makes ChatGPT smarter. It makes you stop wasting the intelligence it already has on questions with no context behind them. A master prompt for who you are, a system prompt for how you want to be answered, and a habit of asking it to disagree with you before it agrees, that’s the entire difference between generic output and something that actually sounds like yours.</p><p>Build the master prompt tonight. Fifteen minutes, one honest conversation with the AI interviewing you back. Everything after that gets easier.</p><p>If you’ve already got a version of this file going, drop what’s in it that surprised you when you first built it, I’m genuinely curious what the interview process pulls out of other people.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=38cbacf479b7" width="1" height="1" alt="">]]></content:encoded>
        </item>
        <item>
            <title><![CDATA[Why 77% of People Using AI Feel Like It’s Failing Them]]></title>
            <link>https://medium.com/@almohtadyg1/why-77-of-people-using-ai-feel-like-its-failing-them-7f08869d3623?source=rss-2db5c10a9beb------2</link>
            <guid isPermaLink="false">https://medium.com/p/7f08869d3623</guid>
            <category><![CDATA[productivity]]></category>
            <category><![CDATA[prompt-engineering]]></category>
            <category><![CDATA[artificial-intelligence]]></category>
            <category><![CDATA[leadership]]></category>
            <category><![CDATA[future-of-work]]></category>
            <dc:creator><![CDATA[Almohtady Bellah]]></dc:creator>
            <pubDate>Mon, 27 Jul 2026 13:01:03 GMT</pubDate>
            <atom:updated>2026-07-27T13:01:03.210Z</atom:updated>
            <content:encoded><![CDATA[<h3>Why 77% of People Feel Like AI Is Failing Them</h3><h4>The other 23% stopped using it and started directing it.</h4><figure><img alt="Image Of Me Relaxed In My Directing Mode (Not Doing Mode)" src="https://cdn-images-1.medium.com/max/1024/1*FIPF1ghPcI3MH-Pd9GrIzA.png" /><figcaption>Relaxed In My Directing Mode (Not Doing Mode)</figcaption></figure><p>77% of employees using AI say it’s actually decreased their productivity and added to their workload. That’s from Upwork’s Research Institute, and it’s not a small sample. Meanwhile 96% of their executives expect AI to boost output company-wide.</p><p>Same tool. Opposite experience. That gap is the whole story, and it comes down to one thing: most people are using AI like a vending machine, put in a request, get a product, judge it once. That’s the wrong model. Below is what’s better, and why.</p><blockquote><strong><em>Reading This Means You Are Not Most People So Bare With Me…</em></strong></blockquote><h3>Most people type one question and judge the first answer.</h3><p>What’s better: <em>treat the first output as a rough draft, not a verdict.</em></p><p>Why: AI’s first pass is closer to clay than to a finished product. The real value shows up two or three rounds in, after you push back or ask it to defend a choice. Judging AI by round one is like judging a sculptor by their first five minutes with the block. If you bounce off a bad first answer and conclude “it doesn’t work for me,” you’ve stopped exactly where the useful part begins.</p><h3>Most people give vague instructions and hope AI fills in the gaps.</h3><p>What’s better: <em>spell out who it’s working for, what the goal is, and what “done” looks like.</em></p><p>Why: A colleague can infer what you mean from years of shared context. AI has none of that unless you supply it. Vague input produces vague output every time, and there’s no shortcut around this. The effort you put into a request is roughly the effort you get back.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*315bgtxNZZc81f30" /><figcaption>Photo by <a href="https://unsplash.com/@dawson2406?utm_source=medium&amp;utm_medium=referral">Stephen Dawson</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Most people try to wordsmith the perfect prompt.</h3><p>What’s better: <em>give three to five real examples of what you want the output to look like.</em></p><p>Why: Describing quality in the abstract is slower and less precise than showing it. An example does the work that twenty minutes of prompt-tweaking can’t, because you’re no longer explaining “good,” you’re pointing at it directly.</p><h3>Most people dump everything they have into the prompt, assuming more context helps.</h3><p>What’s better: <em>give the cleanest, tightest version of exactly what’s needed.</em></p><p>Why: Extra information doesn’t make AI smarter, it buries the instruction that actually mattered under noise. This is well-documented enough to have a name, context rot, where performance drops as irrelevant detail piles up. A tight brief beats a junk drawer.</p><h3>Most people never tell AI anything about themselves, then wonder why the output sounds generic.</h3><p>What’s better: <em>show it your own past work before asking it to sound like you.</em></p><p>Why: If you want AI to write emails in your voice, don’t describe your tone in adjectives, point it at emails you’ve actually written and have it extract the pattern first. It can’t sound like you if it’s never been introduced to you. That introduction is the step almost everyone skips.</p><h3>Most people ask AI whether their plan is good.</h3><p>What’s better: <em>ask it to argue with you instead.</em></p><p>Why: These systems default to agreeable, because agreeableness is part of what they’re trained to optimize for. Asking “is this good?” will usually get you “yes.” Telling it explicitly to act as a skeptical reviewer and find the weak point gets you something you can actually use. The plan gets sharper the moment you ask for friction instead of validation.</p><h3>Most people phrase instructions politely, the way they’d talk to a person.</h3><p>What’s better: <em>be blunt, and lean on “never do this” over “could you maybe avoid this.”</em></p><p>Why: Models follow a hard constraint more reliably than a soft one. Politeness isn’t the currency that works here, clarity is.</p><h3>Most people trust AI’s answers at the same confidence level it delivers them in.</h3><p>What’s better: <em>separate its speed from its accuracy, and inspect anything that would cost you if wrong.</em></p><p>Why: AI can hand you something completely false with the exact same tone it uses for something completely correct. There’s no hesitation built in to warn you. A useful habit here is having a second AI review the first one’s work before a human sees it, then feeding that critique back in. Two rounds against each other beats one confident pass.</p><figure><img alt="" src="https://cdn-images-1.medium.com/max/1024/0*L4DzTBUJLdiQOz13" /><figcaption>Photo by <a href="https://unsplash.com/@medion4you?utm_source=medium&amp;utm_medium=referral">Norbert Braun</a> on <a href="https://unsplash.com/?utm_source=medium&amp;utm_medium=referral">Unsplash</a></figcaption></figure><h3>Most people stay the one doing the typing, copying answers into the next step themselves.</h3><p>What’s better: <em>move from “I use AI” to “AI runs this process,” with you reviewing instead of producing.</em></p><p>Why: This is the actual leverage point. Using AI still makes you the bottleneck between steps. Running a process through it means an entire workflow operates while you check the output. The catch: you can’t automate what you’ve never done by hand. If you can talk through every step of a task like a checklist, AI can usually run that checklist. If you’re still inventing the process as you go, it will struggle right along with you.</p><h3>Most people mistake a fun AI project for a productive one.</h3><p>What’s better: <em>check whether it moved a real number.</em></p><p>Why: Building a slick automation feels like progress, and that feeling is seductive on its own. But a week spent exploring tools that doesn’t move revenue, hours saved, or error rate isn’t a business improvement, it’s a hobby with better branding.</p><h3>Most managers dabble with AI themselves and expect their team to run with it.</h3><p>What’s better: <em>change how you personally work first.</em></p><p>Why: Teams don’t out-adopt their leader. If the person at the top is only casually experimenting, the team stays casual too, no matter how many tools get rolled out. Adoption spreads by example, not by mandate. And underneath most of the resistance to any of this is something simpler than a skills gap: a reluctance to stop being the one who does the work and start being the one who directs it.</p><h3>Where to start</h3><p>Pick one task you already know how to do by hand, not your hardest problem, your most repeatable one. Give the model an example instead of a description. Ask it to argue with your first idea instead of approving it. Push past the first draft. And when something it produces actually lands, ask it to write out the reasoning behind that result so you can reuse it on purpose next time, instead of hoping to stumble into it again.</p><p>The gap between the 77% who feel like AI is working against them and the smaller group who’ve made it central to how they operate isn’t about budget or model access. It’s about whether you’ve actually introduced yourself to the thing you’re working with.</p><img src="https://medium.com/_/stat?event=post.clientViewed&referrerSource=full_rss&postId=7f08869d3623" width="1" height="1" alt="">]]></content:encoded>
        </item>
    </channel>
</rss>