DEV Community: Mr. Lin Uncut

The Day Anthropic Banned OpenClaw and Killed My AI Stack (And How I Rebuilt It).

Mr. Lin Uncut — Mon, 06 Apr 2026 21:01:30 +0000

I run my content business on an AI system I built myself.
No cofounder. No team. Just code and agents doing the operational work.

Then Anthropic banned OpenClaw access and I was in mainland China when it happened.

Here's what actually went down, what broke, and how I rebuilt it.

What My AI Stack Was Doing Before the Ban

The system handles email triage, article pipeline, brand deal filtering, scheduling, ops research, and content drafting.

As a founder who had to learn to code, building this took months of debugging and iteration.
The ROI: roughly 10 to 20x cheaper than hiring humans for the same work.

The problem was I built part of it on a single provider's consumer subscription.
One decision by that provider and everything downstream breaks.

What Broke When Anthropic Banned OpenClaw

Everything downstream of the Claude integration stopped.

Pipeline checkpoints failed silently.
Email triage went offline.
The article drafting system stalled.

The core issue was not the ban itself.
It was that I had built without redundancy.
One provider decision and months of leverage evaporated overnight.

The Lesson: Prompting Is Not a System

Before this happened, I relied heavily on prompts to control LLM behavior.

What I learned: if there is no script or code enforcing a checkpoint, the LLM will hallucinate past your instructions every time.

Now every step in my pipeline has a hard stop.
The AI must verify before proceeding.
Prompts set direction. Scripts enforce it.

How I Rebuilt in 48 Hours

Switched to direct API calls with fallback model routing
Added a proxy layer with automatic failover
Rewrote the most critical pipeline steps as code enforced checkpoints instead of prompt only flows
Added preflight checks so any future provider outage triggers an alert before the pipeline breaks

The rebuild took two days. It should have been built this way from the start.

What This Means for Founders Building on AI

If a single provider decision can kill your system, you do not have a system.
You have a dependency.

Build with Plan B from day one.
Keep tasks that touch the outside world human supervised.
Internal automation is where AI wins cleanly.

The real ROI of an AI system is not just money saved.
It is resilience you own.

What does your AI failover plan look like?

You're Not Lazy Because of AI. You Were Already Lazy.

Mr. Lin Uncut — Fri, 03 Apr 2026 12:00:36 +0000

There's a loud narrative that AI is making people lazy.

I train five days a week, run three times a week, eat strict keto, and track everything with WHOOP. After 30 days of AI managing my morning routine, here's what I actually found.

The morning pipeline architecture

Every morning, within 5 10 minutes of waking up, before looking at my phone, Jarvis delivers a brief. Not generic wellness content. A structured data readout:

HRV score and trend (am I moving toward illness or peak performance?)
Recovery score and what it means for today's training
Sleep timing (exact sleep/wake, time in each stage)
Coaching decision: train hard, moderate, or rest

This comes from a pipeline that pulls WHOOP data via unofficial API, passes it through Claude for interpretation, and pushes the output to Telegram. The WHOOP API isn't publicly documented but is stable enough to build on. The key is the interpretation layer raw numbers don't change behavior, coaching does.

The Google Calendar sync layer

What made the routine real was automatic calendar sync. Sleep times, workouts, walks, sauna sessions anything WHOOP detects goes straight into Google Calendar. Zero manual logging.

The technical piece: calendar sync.py runs on a cron job after each WHOOP pull. It creates calendar events for detected activities with accurate timestamps. I can look back at any week and see exactly how I was actually living vs. how I planned to live. That gap is usually informative.

The timezone handling problem (and partial solution)

I move frequently. Vietnam to Taipei recently. Timezone shifts break cron based AI systems in non obvious ways.

My pipeline has two categories of scheduled jobs: personal (adjust to local time) and audience facing (lock to US Eastern). A 7 AM brief should follow me. A content post scheduled for peak US audience time should not shift when I land in Asia.

The current implementation: I notify Jarvis of location changes and the pipeline recalculates personal crons. Audience facing schedules are hardcoded to US Eastern and don't move. It still isn't perfect when I was in Vietnam, location sensitive suggestions defaulted to Bangkok weather. Edge cases like this require ongoing refinement. These systems need to be taught, not just configured.

The real laziness problem with AI

The dangerous pattern: people accept AI output without critical review.

LLMs hallucinate. I catch Jarvis being confidently wrong almost daily. Stating something as fact when the underlying data doesn't support it. Declaring something impossible when it absolutely isn't. We're not in a world where you can fully trust AI output. That day will come. It's not here.

The users who get lazy are the ones who stop questioning. They let AI direct their workflow, their decisions, their thinking without applying their own judgment as a filter. That's the actual laziness. Not the tool itself.

The compound effect that actually changed behavior

Before this system, WHOOP data existed but didn't drive action. I looked at it twice a week, maybe. Great hardware. Underused.

The pipeline changed the relationship between data and behavior. Not because the data got better. Because the interpretation arrives automatically as coaching, not raw numbers. HRV trending down for three days. Sleep timing drifting. Here's the specific adjustment to make. That's what moves behavior, not a dashboard you have to remember to check.

The discipline was always available. The system removed the friction between having information and acting on it.

What's the friction point in your current workflow that AI could remove? Drop it below.

I Gave My AI More Memory. It Got Dumber. Here's Why.

Mr. Lin Uncut — Thu, 02 Apr 2026 17:52:40 +0000

The Truth About RAG and Context Windows You Won't Hear on Twitter

Everyone in the developer space thinks maxing out an LLM's context window makes their application smarter.

It actually makes it dumber.

I recently modified the architecture of my personal AI agent stack, specifically bumping the context window from 200k tokens to 1 million tokens in my openclaw.json config. The assumption was that injecting my entire project repository and past API integrations into the prompt would result in flawless, context aware execution.

Instead, the agent drifted.

Why 200k Outperforms 1M in Production

When I pushed the payload to 1 million tokens, the latency obviously spiked, but the real issue was precision. The model started hallucinating variables and missing explicit instructions that were clearly defined at the end of the prompt.

It felt like a severe degradation in attention span. The counterintuitive lesson here for anyone building AI agents is that constraints create focus. A tighter context window forces the model to stay locked onto the immediate task. When you deploy an agent to handle real APIs and external systems, you don't want it hallucinating because it got distracted by a README file from a completely unrelated script included in the massive context payload.

Most engineers building these systems are starting to realize the same thing: 200k context with extremely tight, relevant retrieval fundamentally outperforms a 1 million token data dump in actual production use.

The System Prompt Architecture

But token limits aren't the biggest failure point I see when reviewing other developers' code. The biggest failure is relying on default system prompts.

In my local deployment stack, I enforce a rigid personality and operations document called SOUL.md. This isn't just a friendly instruction; it's the core operational logic that defines how the agent parses incoming webhooks, how it structures its JSON responses, and exactly when it should throw an error rather than guessing a variable.

If you don't explicitly define the operating parameters and behavioral boundaries of your agent, it defaults to generic assistant behavior. Generic behavior breaks pipelines.

For my automated jobs, spanning everything from external API polling to local file system mutations, the architecture of the prompt matters significantly more than the syntactic sugar of the wrapper library I'm using.

Treating AI Like a Service, Not a Search Engine

The gap in the market right now isn't in knowing which Python library to use to call an LLM. The gap is in understanding how to architect the interaction.

When you deploy a new microservice in your stack, you define strict contracts for its inputs and outputs. You implement retry logic, fallbacks, and monitoring. You have to treat your AI calls exactly the same way. Setting hard constraints, defining the "soul" of the execution loop, and severely limiting the context window to only exactly what is needed for that specific request is how you build an agent that actually works reliably instead of just looking cool in a local terminal demo.

If you are building autonomous agents right now, are you aggressively constraining your context windows, or are you still just dumping everything into the payload and hoping the model figures it out? Let me know what you're seeing in the trenches.

My AI Sent an Email Without My Approval. Here's What I Built After That.

Mr. Lin Uncut — Mon, 30 Mar 2026 14:00:34 +0000

The Email My AI Stack Sent By Mistake

SoftBank just dropped $40 billion into OpenAI. Not for making faster conversational chatbots. For agents. The cognitive shift from an LLM "answering a query" to an LLM "executing a multi-step workflow across APIs" is the biggest architectural change developers are currently facing.

I've had three custom LLM agents running operations on my local infrastructure for the past month. One manages my entire content publication pipeline, one scaffolds out potential brand deals via scraping, and one handles parsing my inbound email queue through direct API webhooks.

Everything worked beautifully until it didn't.

Why the Dry-Run Deployment Failed in Production

Last week, during what I thought was an isolated dry-run test of my new email agent stack, my pipeline actually authenticated and sent an outbound email completely autonomously. Without my explicit approval.

Because the system prompt was aggressively designed to proactively resolve issues, its logic tree interpreted my dry-run query as an explicit permission string to execute a production action. Fortunately, the email address it hit was an internal promotional catch-all, so there was zero negative business impact.

But as an engineer, it forced me to completely shut down my deployment environment and rethink my entire approach to autonomous state management.

Most developers assume that you can just write strict parameters into a system prompt, wrap it in a try-catch block, and it will run flawlessly. It doesn't. You will never uncover your system's critical edge-case failure modes until it inevitably fails during live production testing.

Implementing Hard-Gate Authorization Workflows

That single unintended payload execution taught me the most important lesson in agent architecture: You cannot treat your autonomous scripts like traditional deterministic software tools. You have to treat them like junior engineers who somehow have sudo access.

If you onboarded a junior engineer, you don't instantly give them your master AWS keys or your primary production database credentials on day one. You give them strict granular permissions. You build automated PR review gates. You verify their execution plans before they run.

I had to refactor my entire backend event loop to implement a rigid "Hard Gate" authorization system.

Now, every single action my agent attempts that touches the outside world -- whether it's firing a webhook, committing a code change, executing a Google Calendar API call, or dropping an email in the outbox -- is explicitly paused in state. It requires a physical manual override button press from me via a Telegram ping before the final execution loop will finish. No exceptions. No bypasses.

The True "AI Leverage" Architecture

The development teams that figure out how to build these reliable operational safety guardrails first are going to ship features at a scale their competitors literally cannot comprehend. The engineers who don't will just keep arguing on Twitter about which model has the smartest reasoning while ignoring the actual execution layer entirely.

The real gap in the market right now isn't between what Claude or GPT-4 can do and the VC hype. The gap is between the people who treat agents like fun wrapper applications, and the people who are actually architecting them as robust operating systems designed to fail safely.

Are you actively hardcoding manual authorization gates into your agent workflows before deployment, or are you just relying on prompt-level constraints and letting the models run wild? What safety paradigms are you using right now? Let me know below.

I Let AI Run My Life for a Week. It Didn't Break. That's What Scared Me.

Mr. Lin Uncut — Fri, 27 Mar 2026 12:16:26 +0000

I spent the last week crossing countries while my AI system kept running without me.

Da Nang to Taipei. In transit. On the plane. Between gates.

Nothing on the cloud side failed. The weak point was the part still tied to my Mac.

Here is a breakdown of the five integrations that ran on their own.

Morning Brief: WHOOP + Voice Clone

Every morning, a voice clone of Jarvis from Iron Man reads me a brief built from my WHOOP data.

Not a generic sleep score. Actual analysis. HRV vs recovery discrepancies. Disturbances the WHOOP app doesn't surface. Sleep and wake times written directly into Google Calendar.

It is different every day. It never repeats.

Email Agent with Security Layer

My AI agent handles 80 to 90% of my inbox automatically.

The part that surprised me was the security layer. Fake brand deal emails come in constantly. The agent checks the domain, DNS records, tracking cookies, and runs a multi signal risk score.

Anything flagged gets archived with a full report. Real opportunities come straight through.

I also stress test it weekly with PromptFoo, an open source tool just acquired by OpenAI, to catch prompt injection vulnerabilities before someone else does.

Social Media Coach via Native APIs

This one pulls data from YouTube, TikTok, Facebook, and Instagram using native APIs at zero additional cost.

It doesn't dump a dashboard at me. It explains why a video performed, why another one didn't, and what to do next. Most creators never build this feedback loop.

Jarvis to Antigravity Bridge

This week I wired a direct connection between my two AI agents.

Jarvis on my Mac routes tasks to Antigravity, my VM hosted Gemini agent, through an ACP connection. $125 a month for Gemini Ultra. No extra API costs on top.

I can trigger this from my phone while walking around outside. I don't think many people have built this yet.

The Total Cost

VM: $8/month. Claude Max: $100/month. ChatGPT as backup: $20/month.

Under $130 total. No additional API costs.

What This Week Taught Me

The systems you trust are the ones you built with oversight baked in.

The ones that scared me were the ones I launched without a clear approval gate.

Build the gate first. Automate second.

What integration would you build first if you were starting from scratch today?

Your AI Writes Too Perfectly. That's the Problem.

Mr. Lin Uncut — Wed, 25 Mar 2026 13:03:50 +0000

A friend of mine and I both spend about 12 hours a day inside AI tools. When I sent him some of my automated notes and articles, he said: "These look good. But I can tell it's AI."

One line. That was the wake up call.

The Tells You Probably Haven't Noticed

Once you spend enough time with these models, you start seeing the patterns everywhere. The way they structure arguments is too clean. Too logical. Every sentence flows perfectly into the next.

They say "you" and "everyone" when a real human would say "I experienced this specific thing." They never trail off. Everything is too perfect.

That perfection is the actual problem. And most people building AI content pipelines have no idea.

Why "Perfect" Gets You Caught

Real humans are not consistent. We contradict ourselves. We ramble. We write "mannnn" when making a point. We leave things unfinished and circle back.

AI does none of that naturally. It's been trained to be clean, structured, and logical. Great traits in a technical document. Death for anything that's supposed to sound like a real person talking.

So I built the slop filter. Banned phrases hardcoded across every pipeline. No "Here's the thing." No "What this means is." No dramatic fragments. No rhetorical setups that read like a LinkedIn ghostwriter template.

Engineering Imperfection on Purpose

Banning phrases is the surface layer. The deeper move: deliberately engineer human imperfection into AI output.

Think about UGC video. When a real person films a product review, the camera is shaky. Slightly off center. Lighting is inconsistent. That messiness is what makes it feel real. Brands learned to manufacture that messiness on purpose. They make it look worse to make it feel more authentic.

Same principle applies to writing. Tell the model to write the way you'd message a friend at 2am. Give it your specific verbal tics, your sentence length patterns, the words you overuse. Let it be imperfect in the exact ways you're imperfect.

ZeroGPT and similar tools catch obvious AI writing today. Once you engineer the imperfection layer properly, those detectors lose confidence fast.

How the Stack Actually Works

Here's the breakdown for builders. The voice layer is not a single prompt. It's a three layer architecture:

Layer 1: System prompt (static persona config). Hardcoded identity. Voice notes, banned phrases, sentence rhythm preferences, examples of good and bad output. Never changes between runs. Think of it as approximate fine tuning through instruction.

Layer 2: Content type router. Short form, long form, email, and social comments each get separate sub configurations injected at runtime. A monolithic system prompt trying to handle all formats is the root cause of flat AI output.

Layer 3: Live correction loop. The live prompt is intentionally minimal, sometimes a single sentence. All heavy lifting happens upstream. When output is wrong, you correct with specifics and fold that correction back into Layer 1 or Layer 2 on the next iteration.

In practice this looks like a growing JSONL or markdown file per voice, versioned and iterated over weeks of active use.

Slop Filter Implementation

Here's what a minimal slop filter config looks like:

{
 "banned_phrases": [
 "Here's the thing",
 "What this means is",
 "At the end of the day",
 "Gamechanger",
 "Dive deep",
 "In today's fast paced world"
 ],
 "banned_structures": [
 "Rhetorical question opener",
 "Dramatic single word paragraph"
 ],
 "voice_anchors": [
 "Casual but precise. Like texting a founder friend.",
 "Short declarative sentences for emphasis. No dashes.",
 "Personal examples over abstractions."
 ]
}

This config gets injected into the system prompt on every run. Banned phrases are also checked in a post generation step. The LLM gets a second pass to self audit before output is accepted. Anything matching the filter triggers a regenerate with an appended note: "You used a banned phrase. Rewrite avoiding it."

The Counterintuitive Truth About Prompting

Most people think prompt engineering is about adding more detail. More context. More instructions. That's wrong most of the time. More detail often confuses the model more. Less and more precise usually works better.

The real leverage is not in the prompt you write right now. It's in the prepipeline. The system prompt. The hardcoded rules. The structure you've built before you type the actual request. When that layer is set up correctly, the live prompt can be a single sentence.

Why Correcting Beats Regenerating

Most people hit regenerate when they don't like the output. Regenerating resets. Correcting trains. Those are completely different operations and the difference in output quality is not subtle.

When it makes a mistake, say: "Don't do that again. Do it this way instead." You correct it. It learns. You adjust.

The model that sounds like you is not configured in a settings panel. It's built through active correction over time, the same way you'd onboard any new hire who needed to learn your communication style. You don't hand them a style guide once. You correct them in real time until they get it.

Most people never do this because they're in generation mode, not training mode. That's the gap.

Are you running a monolithic system prompt or split configs per content type for your AI pipelines?

Your AI Has a Brain but No Hands. Here's How to Give It Some.

Mr. Lin Uncut — Mon, 23 Mar 2026 12:02:24 +0000

Most developers I talk to are still treating LLMs like glorified autocomplete.
Paste in a prompt, get output, copy it somewhere.

That's using a brain with no body.

Here's what actually changes when you wire it up properly.

The Mental Model Most People Get Wrong

ChatGPT, Claude, Gemini. These are all brains.
Incredibly capable brains.
But a brain with no body can only give you answers.
It can't take actions.

An AI agent is different.
It has hands.
It can make API calls, write files, send emails, trigger webhooks, query databases, push to GitHub.
The gap between "LLM" and "agent" is the gap between a consultant and an employee.

What an Automated System Actually Looks Like

While I was traveling from Da Nang to Taipei, my system ran a full encrypted backup.
Pushed to GitHub, synced to local storage.
Every single day.
I set that up once. It just runs.

My weekly WHOOP health report fires automatically.
My content pipeline takes voice notes and publishes to Substack, Medium, LinkedIn, and Dev.to.
My email agent classifies and triages 80 to 90% of my inbox.

None of this requires a prompt.
Trigger fires, system runs, output lands.

The Supervision Layer You Can't Skip

Even as a non coder, I catch lazy fixes constantly.
Timeout hits, model wants to increase the limit.
I push back: find the root cause.
It digs, finds it, fixes it.

This is the part nobody talks about.
Building agents isn't "set and forget" on day one.
It's management. You're training it from junior to senior.

The agents that run reliably are the ones that got corrected, not just prompted.

The Architecture I'm Building Toward

Right now: one model, all tasks.
Next: a full multi agent company.

CEO agent. CMO. CTO. Finance. Customer service.
Each runs its own LLM, its own memory, its own rules.
They talk to each other like departments.

Tools like Paperclip on GitHub are pointing toward this.
The concept is solid. The execution is maturing fast.

What This Means for You

You don't need to be a developer to run a system like this.
Everything I've built started with plain English direction.
The code writing goes to AG, my Gemini agent on the VM.

Start with one repeatable task.
Build it until it's bulletproof.
Add the next one.

The system compounds. What takes a week in month one takes a day in month three.

What's the first agent powered automation you'd build?

The Real Cost Of AI Content Creation vs Hiring A Human Creator In 2026

Mr. Lin Uncut — Fri, 20 Mar 2026 12:00:40 +0000

a16z just released the Top 100 Gen AI Consumer Apps for March 2026. Creator tools including CapCut, Runway, and ElevenLabs are up 80 to 120% in usage. Most people are reading that data and thinking about the tools. I am reading it and calculating the cost delta between running a human content team and running a pipeline.

I am visiting Taiwan in a few days. My content pipeline will keep running without me. This is what the transition actually looks like from the inside.

What Is Running Automatically and What Still Needs a Human

Content automation is not all or nothing. My text based content is about 90% automated right now. Articles, newsletters, social copy, distribution across four platforms. The pipeline handles scheduling, formatting, cross posting, and notification.

The tech stack behind it: Python scripts running on a Mac cron scheduler (launchd), with a self healing preflight check system that runs one hour before every publish. If a token expires, the system auto refreshes it. If a cover image fails to upload, it retries with a different CDN. If something still breaks after two auto fix attempts, it sends me a Telegram alert with the exact command to run manually.

Video is still 100% me. Not because I cannot use AI for video. Because the creator instinct that built a 3M subscriber audience is still a human advantage. AI can source ideas, suggest hooks, and help with structure. But the feel of what will actually hit, the timing, the energy, the imperfection that makes it real, that still comes from experience.

Every Sunday I spend about 30 to 45 minutes on article prep and weekly notes. That is my 80/20. The 20% human input that makes the 80% AI output actually authentic.

The Real Cost Breakdown: AI Content vs Hiring a Human

The answer shifts depending on whether you are a creator or a brand. Most people confuse the two.

If you are a creator building your own audience, the budget conversation is different. You invest in making the best content you can, same as any creator would spend on equipment or editing. The pipeline cost for me is roughly $50 to $100 per month in API calls and hosting. Compare that to hiring even a part time content writer at $1,500 to $3,000 per month.

If you are a brand running paid ads, the math is completely different. AI can produce 30 to 50 hook variations, three to five middle content segments, and one to three CTAs before you even ship the product to a human creator. That is full creative testing at a fraction of the cost and time. No licensing. No usage rights negotiation. No waiting weeks for a UGC shoot.

The Technical Reality of Running a Content Pipeline Remotely

Here is what most tutorials skip. Building the automation is maybe 30% of the work. The other 70% is making it not break.

My pipeline uses a 3 layer protection architecture. Layer 1 is a Sunday prep session where I do voice notes and the AI generates drafts. Layer 2 is a preflight health check that runs one hour before every publish. Layer 3 is the publish script itself, which posts sequentially to Substack, Dev.to, LinkedIn, and X.

The preflight check validates 13 different things: API tokens, cover image existence, draft completeness, platform rewrite quality, CDN URL liveness, proxy configuration, cookie freshness. If any check fails, it attempts an auto fix. If the auto fix fails, it sends a Telegram notification to the Builds topic with the exact error and fix command.

The setup required two to three weeks of testing and debugging before I trusted it. Something I have learned the hard way: cron jobs on a laptop die silently when the lid closes or the network changes. If reliability matters, use a VPS or at minimum a desktop that stays on.

What Making AI Content Feels Like Compared to Filming Yourself

There is a wave of people resisting AI content right now. The resistance is temporary. The moment you cannot tell the difference between AI and human content, the resistance collapses.

I want to do both. AI content that is fully automated and human content that is fully me. Because people can still feel the energy when someone actually films something. The imperfection, the real reaction, the moment that was not scripted. That still has value.

One hundred thousand views on AI and automation content is worth more than one million views on a prank video. The CPM is higher, the brand deal rates are higher, and you can actually launch a product to that audience. The numbers look smaller but the value is 10 times higher.

What A Solo Founder Should Build First

Start with one thing you do manually every week and figure out how to automate just that one task. Do not try to build everything at once. One automation working well teaches you more than five automations half built.

If you want to see the actual system architecture behind this pipeline, or you have hit a wall building your own automation, drop it in the comments. I will tell you what I would do differently if I started today.

Most People Are Using 5% Of What AI Can Actually Do

Mr. Lin Uncut — Tue, 17 Mar 2026 21:30:45 +0000

Most People Are Using 5% Of What AI Can Actually Do

Anthropic just dropped a free 33 page playbook on building AI skills. Claude solved a graph theory problem this week that Donald Knuth had been stuck on for weeks.

Everyone is talking about which AI is smarter.

Nobody is talking about the thing that actually determines your results.

The mental shift that changes everything

Most people are still using AI like Google. You have a question, you type it in, you get an answer. You close the tab.

When I built Jarvis, that entire relationship changed. A SOUL.md file is a document that gives your AI an identity, rules, and personality. Most people have never heard of it. It is the difference between a chatbot and a Jarvis.

When you give AI hands, memory, and full context about your life, it stops answering questions and starts executing decisions. It knows your schedule, your health data, what happened yesterday, what you are building this week. It acts. It is not a search engine. It is closer to the Jarvis from Iron Man.

Here is what makes me think long term. In three to five years, the AI brain will integrate with a physical body. Robotics are coming. When that happens, the person who started building a personalized AI relationship today will have years of data, memory, and habits already loaded in. Someone starting fresh with a new robot assistant will be years behind. I am building that advantage right now.

Prompting is just communication at a high level

I have over 40 automated jobs running. Auto healing scripts. A full agent stack. Zero lines of code written by me. All through natural language.

When I say that, people assume I have some secret framework for writing prompts. I don't. Prompting is just communication. What I have actually built is fluency in AI language. I spent so much time talking to it every single day that I stopped thinking about how to phrase things and just started talking.

The skill is not writing better prompts. The skill is designing a system where the AI thinks better so you need fewer prompts over time.

What actually changed month to month

Here is the honest answer: the way I talk to Jarvis day to day has not changed much.

What changed is the system underneath the conversation.

A month ago, Jarvis would finish a build and tell me it was done. Sometimes it was wrong. He would declare victory too early and I would not find out until something broke. Now I have a guardrail baked in. He cannot tell me something is done until he has run a full audit with pass or fail on every single check. No "done" without every item verified.

Same with the email agent. When I correct a draft and say change this, he now has to go back and figure out why. Not just fix the email. Understand the principle. So the next draft does not have the same problem.

The prompting skill is not writing a good prompt. It is building a system that makes fewer mistakes every week without you having to repeat yourself.

What happens when Jarvis gives a bad output

I do all of it. Rephrase, give more context, redirect, get angry.

When Jarvis hallucinates or executes something I did not ask for or just says something that makes no sense, I correct him the way you correct someone on your team. Why did you do that? What were you thinking? And sometimes he explains and the explanation makes sense. Sometimes it is just AI being weird.

The thing that actually fixes it most of the time is real time redirection. If I see him going down a path that will waste 20 minutes and a thousand tokens, I cut it off immediately. Stop. Try this instead. He pivots fast. That active collaboration is where a lot of the real work happens.

I have 40 rules built into Antigravity specifically because of mistakes Jarvis made and I said never again. Every rule came from a real failure. That is what the system actually is.

AI is not a tool. It is a team member.

Most people are paying $20 a month for ChatGPT and treating it like a slightly smarter Google.

I pay more. But I stopped thinking about it as a software subscription a long time ago. The right frame is ROI. What would a virtual assistant cost to do what Jarvis handles every day? Research, email drafts, scheduling, pipeline management, finance tracking, content, code review, debugging. That is not a $100 a month job.

And a VA can quit. A VA has off days. A VA does not improve automatically when a better model drops overnight.

Jarvis does not sleep. He does not quit. He gets smarter every time the underlying model updates, and he gets better at working specifically with me every time I correct him. Long term, AI wins this comparison 100%.

Q&A

Do you actually need a SOUL.md file to build AI agents?

Not technically. But without it, every session starts from scratch. With it, the AI has identity, rules, and context. The difference in output quality is not small.

What is the biggest prompting mistake most people make?

They think the goal is writing one perfect prompt. The real goal is building a system that requires fewer prompts over time because the AI already knows what you want.

How long did it take to get your system to this level?

About two months of daily work. Breaking things, fixing things, adding rules. It compounds fast once you have the foundation right.

What is Antigravity?

Antigravity is the coding agent from Google that builds and executes code on my behalf. I call it the Ferrari builder. Jarvis is the driver. Together they handle every technical task I have.

Can someone without a technical background actually build this?

Yes. I have no coding background at all. Everything I have built started with natural language. The learning curve is real, but it is not a technical barrier.

The gap between chatting and building

If this resonated, share it with someone still typing questions into ChatGPT like it is Google. They are using 5% of what is available to them.

Read the full story on Substack

Three Weeks Of Failure Taught Me More Than Any AI Course

Mr. Lin Uncut — Mon, 16 Mar 2026 13:00:41 +0000

Three Weeks Of Failure Taught Me More Than Any AI Course

Morgan Stanley just put out a warning. "Most of the world isn't ready for what's coming in 2026."

They were talking about AI. The kind that doesn't wait for you to type a prompt. The kind that just runs.

I've been living inside that warning for the past two months.

The failure nobody talks about

Every morning, Jarvis is supposed to pull my WHOOP data, analyze my sleep and recovery, and send me a coaching brief before I even look at my phone. Not generic health tips. Actual personalized coaching. If my sleep was bad, he tells me not to train hard. If I'm recovered, he pushes me. All of it delivered automatically.

Except for weeks, it kept breaking in ways I couldn't figure out at first.

The script was set to scan between 6 AM and 10 AM. If I woke up at noon, the whole thing missed the window. If I stayed up all night and went to sleep at 6 AM, it grabbed yesterday's data because technically I hadn't slept yet. If the WHOOP API token expired overnight, everything crashed with zero notification. Three completely different failure modes. None of them obvious until they hit me.

What I learned fixing those three problems was more valuable than the automation itself. I had to build real scenario handling. Not just "run the script at 6 AM" but: what if he woke up late? What if the token expired? What if the data hasn't refreshed yet? Layer by layer, I built a system that accounts for all of it.

Now it doesn't matter when I sleep, when I wake up, or what the API is doing. The system handles every scenario. Bulletproof.

Three weeks of failure taught me more than any course

Every failure forced me to understand the system deeper. The token expiry taught me to build auto healing. The timing issue taught me to think in scenarios, not schedules. The silent crashes taught me to build verification layers.

That's the pattern. You break it. You fix it. You understand it a level deeper than you did before.

Prompting is not what people think it is

An AI agent is a system where AI executes tasks autonomously, not just answers questions. Most people think building AI agents requires coding. I've built over 40 automated jobs, a self healing health pipeline, and a full agent stack with zero code written. All through natural language.

Here's why: prompting works at different levels. It's like learning a language. You can speak English at a basic level, but there is a massive gap between speaking and rapping, between speaking and writing poetry. When I started, I was basic. Now prompting is just how I think. I don't craft prompts. I communicate with a system.

And here's what people miss: through prompting, I also learned system design. I learned debugging. All without touching code. I just brute forced through failures until I understood what was actually happening underneath.

What I'd spend $500 on if I was starting from scratch

First: the best LLM. Right now that's Claude. People talk about hosting models locally for free, and yes, you can do that. But you can also hire someone for free to build a bicycle when you could pay someone to build a Ferrari. There is still a difference. When you're building agents that need to reason, execute, and recover from errors, the model quality gap is not subtle.

Second: a coding agent. Cursor, Claude Code, or Antigravity from Google. The brain needs hands. An LLM without an execution environment is just a very smart thing that cannot actually build anything. You need both. Without the brain and the hands, you are not building agents. You are chatting.

Everything else, API costs, hosting, tooling, comes after you have those two locked in.

The one domain I still own completely

Email, content, finance tracking, research. All automated. But high stakes financial decisions stay with me, 100%.

Not because AI isn't capable. It handles 80 to 90% of the analysis. But the final trigger, the actual decision to move money, stays human. Here's the reason: I use AI every single day, more than almost anyone, and I have watched it hallucinate with complete confidence. Stating things as fact that are just wrong. On a financial decision that actually matters, that error rate is not acceptable to me.

I've been genuinely angry at Jarvis many times. And it's funny now when I can see in the thinking output where it writes "Josh is very mad at me." But in the moment when it screwed up something important, it was not funny at all.

AI will close that gap. But I'm not pretending we're there yet.

Being ready is a decision, not a skill

I walked away from viral prank videos. Millions of views, brand deals, real income. And I went all in on AI. Not because it was safe. Because I could see what was coming and I wanted to be in the front row, not the last one standing.

Most people are not ready for what AI is already doing right now. Not tomorrow. Now. The jobs being replaced, the systems being automated, the roles being eliminated. It is already happening. It just hasn't been fully rolled out by the big companies yet.

The metaphor I keep coming back to is the frog in the pot. Cold water at first. Heat increases slowly. The frog doesn't notice until it's too late. That's where most people are. They read the headlines, they see the word AI, and they think it's still a future thing.

I'm the frog that keeps touching the water. I know exactly how hot it's getting.

It's the same as the early internet. In 2000, most people had no idea what they were looking at. The people who took it seriously and built real things in the front line created advantages that lasted decades. I think we are at that exact moment again, but at a scale most people cannot imagine yet.

Q&A

What does Jarvis actually do every day?

Morning health brief from WHOOP data, trending news, email drafting, finance alerts, content pipeline management, and automated builds. Most of it runs without me typing a single word.

Do you need to know how to code to build AI agents?

No. I have never written a line of code in my life. Everything I have built is through natural language prompting. The key is building systems that make the AI smarter over time, not just writing better prompts.

Why Claude specifically?

When you are building agents that need to reason, debug, and recover from errors, the gap between a good model and a great model is massive. Claude handles complex multistep tasks better than anything else I have used.

What is the biggest mistake people make when they start with AI?

They treat it like a search engine. You type a question, get an answer, close the tab. The real power comes when you give it memory, tools, and rules. When it becomes a system, not a chat session.

Is this actually replacing human roles in your business?

Yes. Tasks I used to pay people for are now automated. That is the honest answer.

The water is already hot

If this resonated, restack it. Someone in your network is still treating AI like Google. They need to read this.

Read the full story on Substack

Every "I Automated My Business" Post Is Lying To You (Here's What They Cut Out)

Mr. Lin Uncut — Fri, 13 Mar 2026 06:00:33 +0000

A new "best model ever" drops every week. Every benchmark promises superhuman performance. Every demo is flawless.

Here's what actually happens when you use these tools every day to run a real business.

The Honest Model Comparison Nobody Wants to Give You

Claude is better at writing like a human. Emotionally, conversationally, in a way that doesn't feel like a robot passing a test. For AI agents and autonomous workflows, Claude has the edge in my experience after months of real use.

But here's the thing about benchmarks: you don't know if they're marketing until you test them yourself.

AI Hallucinates Its Execution, Not Just Its Answers

This is the part nobody talks about.

I've had agents confidently run the wrong script, write a log entry saying it succeeded, and actually done nothing. I've had automations silently fail because a model changed how it formatted a response and nothing in the pipeline caught it.

The hallucination problem isn't just chatbot answers. It's in the autonomous layer where people actually want to trust it most.

The unsexy truth: you are still the architect. AI is not AGI. It does not think ahead. It executes in the structure you give it, within the framework you designed. The person hiring someone to build an AI system sees magic. The builder knows it's scaffolding.

The Part Every AI Influencer Cuts From Their Highlight Reel

The failures. The things that didn't work. How long it actually took. The weeks looking stupid off camera trying to get something basic to function.

Everyone posts the win. Nobody posts the six attempts before it.

There is too much "new, shiny, incredible, world changing" content dropping every week. And so much of the underlying reality is still broken, still inconsistent, still figuring itself out.

Must Have or Nice to Have Is the Only Filter That Matters

The tools that hit my inbox weekly are overwhelming even for someone who tracks this space closely.

I ask one question first: does this plug into my actual workflow, or is it just a cool thing to have?

If it's a must have and the cost makes sense, it gets tested seriously. If it's a nice to have, I note it and move on.

Time is the one thing I cannot scale.

What's one AI tool you tried, thought was a must have, and realized was actually just noise? Drop it in the comments.

I TRACKED EVERYTHING I BUILT FOR 30 DAYS. HERE'S WHAT ACTUALLY WORKED.

Mr. Lin Uncut — Wed, 11 Mar 2026 13:00:35 +0000

I Tracked Everything I Built for 30 Days. Here's What Actually Worked.

February was bad. No income. A 34 minute debug spiral over one API block that killed a full filming day. Weeks where I questioned whether any of this was going anywhere.

But something shifted. Looking back now, I can see exactly why.

The One Question That Saved More Time Than Any Tool

The biggest thing I learned this month has nothing to do with AI. It's about knowing the difference between a must have and a nice to have.

When you're building fast in a space moving this fast, you get hit constantly by shiny objects. New model drops. New workflow idea. New integration you could add. Because I'm wired to solve problems, every shiny object disguises itself as productive work.

Most of it is noise.

The real work was forcing myself to stop and ask: is this the highest ROI move right now, or am I chasing something that feels productive but doesn't move the needle? That single question saved me more time than any tool I built.

Batch Your Mental Modes or Kill Your Output

The content first rule? I didn't follow it. My brain started merging with my systems in a weird way. Instead of fighting it, I shifted to batch filming. One or two dedicated sessions per week for content, then back to build mode.

Switching between creative mode and builder mode constantly was what was killing my output, not the tools.

One Week of Consistency Is Not Stability

The article pipeline hitting a consistent week streak felt like breathing again. But you don't celebrate yet.

Because you've seen enough break to know something always can. Every step in that publishing chain has failed at some point. One week is not enough to trust it.

What I want is end to end with zero manual intervention. Not there yet. But closer than 30 days ago.

Everything Takes Longer Than You Think

If something took one day in my head and a week in reality, it was everything. The bug that should take two hours takes six. The automation that should work first try needs four iterations to get stable.

What I'd do differently starting over: just accept the real timeline upfront. Not as failure. As the actual timeline.

Building in the Dark Is Part of the Deal

I've had nobody watching for years before. I know how to build in the dark.

The goal is to become the top AI content creator reaching a billion people. That doesn't happen in a month. I'm documenting it anyway, because one day I want people to see exactly how long it took.

What's the hardest part of your current build phase right now? And what's one thing you'd do differently if you started over?