DEV Community: Hunter G

Sequoia's 'This is AGI' talk, distilled — what it means if you build on the models

Hunter G — Fri, 29 May 2026 07:35:41 +0000

Sequoia's AI Ascent 2026 keynote ("This is AGI") is worth 32 minutes of your time. I distilled it into the parts that actually change how you build. Short version up top, then the framework.

The one reframe that matters

Most of us have only lived through communication revolutions — the internet, cloud, mobile. They changed how information is distributed. AI is a computation revolution: it changes how information is processed. Different shape of wave entirely.

Why you should care: in a computation revolution the capability floor moves under your feet every day. The thing you built last week can be irrelevant this week.

"This is AGI" — a functional definition

Sequoia isn't proposing a technical definition. Their commercial one is the useful one: if you can dispatch an agent to do a job, it recovers from failure, and persists until the job is done — that's AGI. Three inflection points got us here: pre-training (ChatGPT), reasoning (o1), long-horizon agents (Claude Code). We went from horses 40% faster to cars 40x faster.

If you build on the models: MAD

This is the part for builders. Three pillars:

Moats → go customer-back, not tech-out. Capabilities change faster than customers do. What you build may be obsolete tomorrow; how tightly you wrap around the customer is durable.
Affordance. Claude Code is insanely powerful and has almost no affordance — open a terminal for the average Fortune 500 employee and watch. The opportunity is building the path of least resistance for your customer's specific problem.
Diffusion gap. Capabilities diffuse into the market far slower than they're created. Every day the labs outrun the enterprise, that gap — your opportunity — widens.

And: no lead is safe. You can't pass 15 cars in the sun, but you can in the rain. Right now it's a downpour of new capability.

Agents: the year is 2026

An agent = a brain (model), arms and legs (tools), and persistence (harness). The headline metric: how long a model stays on task without going off the rails went from tens of minutes a year ago to hours today. "SaaS is dead" is backwards — tool value explodes as the number of agents using them grows.

The scale of agenticness: tab-complete → agentic dev → background/async agents spawning subagents → "dark factories" with no human in the loop (already in production, including at security companies). And hiring an agent beats hiring a human on every axis: infinitely scalable, low maintenance, paid in tokens not salary.

The long view: a cognitive revolution

Machines already do 99%+ of physical work. Sequoia's bet: cognition repeats the pattern — soon 99.9% of cognition done by machines, like the Industrial Revolution but bigger and faster. Intelligence becomes like aluminum: once the most precious metal on Earth (displayed at Tiffany's), then disposable after electrolysis.

The close landed on Protagoras: man is the measure of all things. AI can and will do the work — but only human connection gives a reason to care.

Source: Sequoia Capital, "This is AGI — AI Ascent 2026 Keynote." This is my distillation; watch the original for the full argument.

Claude Opus 4.8 is out. The benchmark isn't why I'm switching.

Hunter G — Fri, 29 May 2026 00:00:36 +0000

Anthropic shipped Claude Opus 4.8 today. The benchmark numbers went up, as they always do. But that's not why I'm switching my default model, and I want to explain the part that actually changed how I work.

The numbers, quickly

Here's the official comparison:

The highlights:

SWE-Bench Pro: 69.2% — up from 64.3% on 4.7, well ahead of GPT-5.5 (58.6%) and Gemini 3.1 Pro (54.2%).
Computer use (OSWorld-Verified): 83.4% — still the model to beat for clicking around real UIs.
Knowledge work (GDPval-AA): 1890 vs 1769 for GPT-5.5.
Reasoning (Humanity's Last Exam): 49.8% no tools / 57.9% with tools — top of the table.

And one I'll call out honestly: on Terminal-Bench 2.1, Opus 4.8 scores 74.6% and GPT-5.5 wins at 78.2%. 4.8 jumped a lot from its predecessor (66.1%), but it isn't first on that one. Pick your model for what you actually do.

The part that matters more than any benchmark

Opus 4.8 is roughly 4x less likely than 4.7 to let a code flaw pass without flagging it. It proactively points out uncertainty, questions sketchy inputs, and pushes back on plans it thinks are unsound.

That sounds small. It isn't.

When you hand work to an agent, raw capability was never the real bottleneck — silent failure was. The model that writes a subtle off-by-one and says nothing costs you more than the model that's slightly worse but says "I'm not sure this input is ever non-null, can you confirm?"

Concretely:

Before: it writes a function that looks clean, ships a hidden edge-case bug, says nothing. You find it in production.

After: it writes the same function and adds "there's an edge case here I'm not confident about — double-check the input is non-empty," or flat-out tells you your plan has a hole.

For anyone treating Claude as a coworker that ships work unattended, that calibrated honesty is worth more than a few benchmark points.

Three product changes worth knowing

Dynamic Workflows (Claude Code research preview) — runs hundreds of parallel subagents for big jobs like migrating a codebase across hundreds of thousands of lines.
Effort control (claude.ai, Cowork) — you pick how hard it thinks. Higher = deeper, lower = faster. The speed/quality trade-off is back in your hands.
Messages API now accepts system entries mid-array without breaking the prompt cache — you can inject new instructions partway through a long task and keep your cache. If you build long-running agents, you already know why this matters.

Pricing didn't move

Regular: $5 / 1M input, $25 / 1M output — same as 4.7.
Fast mode: $10 / 1M input, $50 / 1M output — 3x cheaper than the previous fast tier, and it's still Opus, not a smaller model.

Databricks reported 61% lower token cost vs 4.7 on their workloads, because 4.8 uses tools more efficiently and takes fewer steps.

Model ID is claude-opus-4-8, available everywhere today.

My take

The next moat in agents isn't IQ. It's calibrated honesty — the model that tells you when it's unsure is the one you can actually delegate to. That's the upgrade I care about here.

Numbers and image from Anthropic's announcement. Full evals are in the system card.

Codex and Claude Code's /goal Command in Practice

Hunter G — Thu, 28 May 2026 05:50:02 +0000

/goal is a new command that OpenAI Codex CLI (April 30) and Anthropic Claude Code (May 12) shipped within 11 days of each other.

The idea is simple. You give it a completion condition, and it keeps running on its own until that condition is met.

Before /goal, AI coding agents stopped after every turn and waited for you to hit Enter. Even if your prompt said "keep going until X," it would still pause. /goal is the fix.

How the two implementations differ

Codex stores the task locally. Close your laptop, reboot — the task persists and you resume with /goal resume. Controls: create, pause, resume, clear. Persisted workflow on the app-server.

Claude Code takes another route: a cheaper small model (Haiku, by default) acts as a supervisor. After each turn, the supervisor reads the transcript and answers one question: "is the goal met?" If no, keep going. If yes, stop and hand back. Token-wise, the supervisor is billed separately and doesn't eat into the main model's budget.

Two paths to the same problem — let the agent decide whether it's done.

Three before/after scenarios

1. Running a data scrape

Before: You ask it to scrape products from three brands. Finishes brand 1, stops, asks "OK to continue?" You hit continue. Finishes brand 2, stops again. Brand 3 ends at 92% success and you have to manually retry the failures. You spent the whole evening hitting Enter.

After: You say "Scrape all three brands. Auto-retry failures 3 times. Below 95% doesn't count." Close laptop, go eat. Come back: first pass 92%, it retried once on its own, hit 96%, done.

The difference is "95% counts as done." /goal turns that into the agent's call instead of yours.

2. Packaging a Mac app

Before: Build fails, Google, find a 2014 Stack Overflow thread, try it, new error, Google again, try again. 20+ rounds. It's 2 AM and you're still at the keyboard.

After: "Get the build script to produce a shippable package. On failure, read the error yourself, search for fixes, retry until it ships." Close laptop, sleep. Morning: 4 rounds, each diagnosing and fixing a different problem. Package built.

/goal swallows the "read error → search → patch → rerun" human loop.

3. Server down during a business trip

Before: Server crashes mid-trip. Phone can't connect, you can't push fixes, you refresh the monitoring page every 10 minutes hoping it self-healed.

After: Open the laptop and say "Remote into the server, figure out why it crashed, fix it, confirm the endpoint is back." Continue the trip. Get home, already done.

It logged in, read the logs, found the culprit file, deleted it, restarted, verified. Left a note: "Don't let this kind of file slip in again."

This used to be human-only work.

Why this matters

Engineering-wise, /goal isn't hard. Codex is a state machine plus storage. Claude Code is a secondary LLM call.

But it solves a problem that none of the AI coding agents fixed in the last two years:

The main model can't tell if it's done.

It's zoomed in writing code. "Done" needs zoom out. Anthropic's call — let Haiku zoom out — is a beautiful division of labor.

Same week, Anthropic also shipped /loop, /batch, /background. /loop runs N times. /batch parallelizes tasks. /background runs in the background. All three still leave "when to stop" up to you. Only /goal hands that to the agent.

The transfer of the stop bit is the real paradigm shift.

What developers should think about

/goal moves your effort from micromanaging the process to defining the goal.

Four things to write into a goal:

Stop condition — what counts as "done"
Verification — how to prove it's done
Untouchable boundaries — what not to change
Success metric — quantify it (e.g. ≥95% success)

A vague prompt wastes a turn. A vague goal can waste 6 hours.

But a sharp goal lets the agent run for 8 hours without your input.

6 Principles for Designing a Commercial AI Agent (from SaaStr's live self-autopsy)

Hunter G — Sun, 17 May 2026 22:46:51 +0000

SaaStr replaced 13 employees with 3 people + 20 AI agents. Two AI VPs cost $254/month against ~$500K of human cost. Stripped of the shock value, here are six principles for designing an agent that survives as a commercial entity.

1. Design for agents, not humans. Agents don't browse your UI, they call your API. They care about rate limits, OAuth, REST conformance, error handling, webhook reliability. Stripe scored the only A+ on SaaStr's 116-API report card: MCP server, agent toolkit for 4 frameworks, llms.txt at root, restricted keys scoped per-tool.

2. One inch wide, one mile deep. Agent ecosystems don't reward generalists. Agents repeatedly reach for tools with exceptional domain depth. Pick one capability node and own it.

3. Be the tool agents pick. Agents are a new distribution channel. Don't ask "will agents replace me" — ask "will an agent reach for me at the step where my capability is needed."

4. Draw the autonomy boundary. Agents own execution. Humans own judgment and relationships. A well-designed agent knows when to stop, when to escalate, and what it must not do. Assist agents recommend; humans decide.

5. Consistency beats brilliance. There is no set-it-and-forget-it agent. Output is B/B+ but trained daily. Design the operating loop, not just the agent.

6. The flywheel is the moat. Every call makes the agent smarter. Don't bet on the model — it resets every quarter. Avoid "feature, not a company" and "solution in search of a problem."

The agent era is a screening question: a tool agents pick, or a tool agents route around.

The 2026 AI Startup Reality: Survive, Refactor, or Be Replaced

Hunter G — Fri, 01 May 2026 10:07:19 +0000

The 2026 AI Startup Reality: Survive, Refactor, or Be Replaced

In 2026, the air in the AI startup circle is filled with two distinct scents: the technical carnival of continuously exploding Large Models and Agents, and the deep anxiety of countless founders suffering from sleepless nights.

Once, everyone thought AI was the ultimate tailwind, a dividend, an easy wealth code. Now, everyone has sobered up—AI is not a tailwind; it is a reshuffle. Large models are getting stronger, Agents are getting smarter, traditional startup logics have completely failed, old paradigms are collapsing, and new rules have not yet fully crystallized. At this twilight critical point, all AI founders are facing the exact same test: Evolve, or be replaced.

This is not fear-mongering; it is the truest commercial reality of 2026.

1. The Era Has Changed: Models and Agents Are Reconstructing the Internet

When we talk about AI in 2026, we can no longer just stare at the text Q&A in a "chat box." The combination of Large Models + Agents has fundamentally changed the relationship between technology, products, business, and humans.

Over the past few years, the industry debated the most: To B or To C? Vertical models or general capabilities? Tools or platforms? By 2026, these questions are meaningless.

First, the boundary between To B and To C has completely disappeared.
AI is no longer the exclusive capability of a specific product or department; it sinks into the "capillaries" of business like water and electricity. A service aimed at enterprises can instantly reach individuals; a product aimed at individuals can seamlessly integrate into enterprise workflows. What determines product value is no longer who you serve, but what scenario you solve.

Second, the interaction paradigm has shifted from "Human Asks, Machine Answers" to "Fully Automated Execution."
We used to open apps, click buttons, and fill out forms. In the future, Agents will do everything for you. They will proactively understand requirements, automatically dispatch resources, execute tasks across platforms, and deliver closed-loop results. You don't need to "use" AI; the AI "works" on its own.

Third, Agents have become the new gateway to the Internet.
In the past, gateways were search engines, apps, or mini-programs. Now, the gateway is the Agent. The interaction protocol of the Internet is being rewritten by Agents. This means all business models built on "old gateways, old interactions, old logics" face the risk of disruption.

2. Reconstructing the Lifeline: Speed is Life and Death

In the traditional software era, it might take a SaaS company two to three years to reach a million-dollar ARR. Product iteration was measured in "months." Competition was about features, channels, and customer relationships.

In the AI+Agent era, the rules are completely flipped.

1. Scale effects are infinitely magnified.
Model iteration is measured in "weeks" or even "days." The market won't give you time to slowly trial and error.

2. Complete re-evaluation of business models.
Traditional SaaS sold "software usage rights"; the AI era sells "labor" and "results." You buy an Agent's working hours and execution capabilities.

3. Explosive capital efficiency.
The time to reach ARR targets is compressed to 9-10 months. Teams with slow reactions and long processes simply won't survive until the day they can monetize. Speed is the new lifeline.

3. The Cruel Truth: Why Are AI Opportunities Decreasing?

The low-barrier opportunities are disappearing, the space for pseudo-demands is closing, and shallow innovation has no way out.

1. Copying costs approach zero.
Purely functional software no longer has a moat. What you can do, others can do faster; what you charge for, others can do for free. The era of surviving on "feature differentiation" is completely over.

2. The shallow efficiency trap.
Just helping people write copy, edit spreadsheets, or summarize documents is "icing on the cake." When official large models integrate these features directly, you instantly lose value.

3. The Only Moat: Data Sovereignty and Closed-Loop Scenarios.
When features are worthless, what is the real barrier? Data. Not just any data, but deep, exclusive, closed-loop, and iterative data. "Features" are dead; "Data" and "Scenarios" live forever.

4. The Only Path to Survival: Becoming an "AI-Native Company"

Adding an AI customer service bot or an AI writing tool is called "AI+". In 2026, this "plugin AI" is meaningless.

Only AI-native organizations—reconstructed from underlying genes, processes, culture, and people—can survive.

1. Flow Reengineering.
AI is not an auxiliary tool; it is the leader of the process.

2. Hard Metrics of Commitment.
A hardcore standard in the industry: Average monthly Token cost per employee > $1,000. This is not waste; it is standard equipment.

5. Organizational Revolution: 10X/100X Efficiency

1. Token Free for All.
Eliminate the psychological barrier of compute costs.

2. 100% AI Coding.
Future development is not "writing code manually" but "directing AI to write code."

3. 10X/100X Talent.
One person + a suite of AI tools can do the work of an entire past department.

6. Coexisting with Anxiety

Anxiety is not a bad thing; it is a signal for evolution. It means you are standing at the boundary between the old and new eras.

In 2026, there are no more "AI+ companies," only AI-native companies. There are no more "traditional founders," only "evolutionaries adapting to the AI era."

Survive, Refactor, Evolve. This is the most hardcore survival law of AI entrepreneurship in 2026.

DeepSeek V4: The Death Line for Silicon Valley

Hunter G — Fri, 01 May 2026 09:06:32 +0000

DeepSeek V4: The "Death Line" for Silicon Valley - Why Token Efficiency is the True Path to AGI

Recently, the model war in Silicon Valley has entered a white-hot phase of high-intensity gaming.

The launch of DeepSeek V4 coincided almost exactly with Kimi K2.6, OpenAI's GPT-5.5, Google's next-generation TPU announcement, and Anthropic's latest funding news. It is a true clash of titans. But if you look closely, Silicon Valley's reaction to DeepSeek this time is fundamentally different from previous generations. What they feel is no longer pure "surprise," but structural fear.

Because what DeepSeek V4 brings is not just a next-generation large model with invincible benchmark scores, but a "death line" drawn for American foundational model companies.

Why Has Efficiency Become a Part of Intelligence?

Previously, we believed that the only path to AGI (Artificial General Intelligence) was to recklessly stack computing power—more GPUs, larger parameter scales, and stronger closed-source moats.

But DeepSeek V4 proved that: Without extreme efficiency, AGI will always just be a demo sitting in a server room. Only when cost and efficiency reach a certain critical point can AGI truly become infrastructure for all of humanity.

On a technical level, DeepSeek V4 continues to leave everyone in the dust when it comes to Token Efficiency. Several of its core technologies have pushed large model architecture into a new dimension:

CSA (Compressed Sparse Attention) and HCA (Heavily Compressed Attention): Greatly reduces the computational complexity of the model when processing long contexts, supporting up to 1,000,000 tokens of ultra-long context.
mHC (Manifold-Constrained Hyper-Connection): Performs surgery on the information transmission channels of the neural network, achieving stronger information representation with fewer parameters.
Muon Optimizer: This is the nuclear weapon of training efficiency, pushing training stability and resource utilization to the extreme.

What is the result? The compute cost is compressed to 1/3 of the traditional architecture, and the memory footprint is reduced to a terrifying 1/10.

While American model vendors are still having headaches over training bills of tens of millions of dollars a day, DeepSeek simply flipped the table—intelligence itself is no longer scarce; "cheap intelligence" is the ultimate moat.

The "Death Line" and Silicon Valley's Diverging Paths

Jenny Xiao, a former OpenAI researcher and partner at Leonis Capital, mentioned a very sharp viewpoint in a recent discussion:

"If you are a foundational model company, and you are surpassed by an open-source company, the value of your business is basically zero."

This explains why the current appetite of the capital market for Anthropic is even greater than for OpenAI. Many institutions are even trying to sell off OpenAI shares before its IPO.

The reason is simple:

OpenAI chose "Big and Comprehensive": Trying to cover all scenarios with more expensive and massive models (like GPT-5.5). But their high pricing is being crazily eroded by lighter, cheaper open-source models.
Anthropic chose "Less but Better": For example, launching Claude Code and going all-in on "Agentic Coding". Because in the eyes of AI, all computer tasks are essentially programming. Winning over programmers means winning the API definition rights to AGI.

Reconstructing the Compute Stack: Will NVIDIA Fall from the Pedestal?

As DeepSeek V4 has been confirmed to be adapted to domestic chips like Huawei Ascend, another long-unresolved question has been brought to the table: How long can NVIDIA's dominance remain solid?

Senior chip architect Zhibin Xiao gave an objective judgment: In the short term, NVIDIA will not be replaced. Because the ecosystem barrier of CUDA is not just operators, but also includes communication, training stability, and massive developer inertia.

But long-term cracks have already appeared. The war of large models is shifting from the "training side" to the "inference deployment side."

On the inference end, a chip no longer needs to "rule them all." Heterogeneous computing will become the norm—some chips are specifically responsible for Attention calculation, and some are dedicated to KV Cache storage scheduling.

When the software architecture (like DeepSeek) can perfectly perfectly abstract away non-NVIDIA underlying compute power, the Chinese AI ecosystem, in a desperate situation where hardware is blocked, abruptly completed a shocking breakout through the extreme extraction of software-side efficiency.

The Endgame: From Benchmark Machines to "Systemic Competition"

The paradigm of AI competition has changed.

The significance of DeepSeek is that it makes the big shots in Silicon Valley clearly see: The war of large models is shifting from a single Benchmark competition to a brutal systemic war.

Model architecture, Token efficiency, underlying chip adaptation, software abstraction stacks, commercial pricing, and the open-source ecosystem—these are no longer scattered links, but different battlefields of the same war.

On the eve of the full explosion of the Agentic era, the future winners will definitely not just be the companies that can build the "smartest brain."

The true king is the one who can seamlessly distribute intelligence to the most enterprises and developers in the world with the lowest cost, fastest speed, and most stable compute stack.

And this time, DeepSeek is standing in the very center of the poker table.

YC CEO Demonstrates GStack: Why Your AI Agent Framework is Built Wrong

Hunter G — Wed, 29 Apr 2026 21:09:27 +0000

Y Combinator CEO Garry Tan recently dropped a bombshell demonstration video that shook the tech community. As an early core engineer at Palantir and a star founder who sold his startup to Twitter, Garry spent the last two months using Agents to rewrite his former startup project—a project that originally cost $10 million and took 10 engineers two years to build.

More importantly, he open-sourced a framework called GStack and threw out a highly disruptive architectural thesis: "Thin Harness, Fat Skills."

In this article, we will deeply deconstruct the "New Silicon Valley AI R&D Paradigm" shown in the video and see how a human commands a top-tier product development fleet composed entirely of digital lifeforms.

1. The Awakening: AI is No Longer a Tool, But a Regular Army

Garry Tan's sigh at the beginning of the video probably represents the voice of all top hackers right now: "I've coded more in the past two months than I did in all of 2013."

Before this, the industry's perception of AI programming generally stayed at the "Copilot" stage—you write some logic, and AI helps you complete the rest; you encounter a bug, and you paste the error log to AI for analysis.

But in Garry's demonstration, this dialog-box-based "outsourced" collaboration has been completely eliminated.
He astutely pointed out the fatal flaw of current monolithic large models: Because they lack deep contextual memory of your private codebase, if you ask it to directly write a complex system, it will start to "reasonably guess." In the face of a massive codebase, this guessing leads to catastrophic crashes that look perfect but fail on execution.

Since the AI's intelligence is already high enough, why does it still crash?
Garry's answer is deafening: "Humans have never built software by relying on one person. Humans build software through teams, role division, standard operating procedures (SOPs), and code review. Since LLMs are now replacing human work, we must make them follow human team collaboration logic."

This is the background of GStack's birth. It's not a plugin that teaches LLMs how to write code; it's a "Digital Human Organizational Architecture System." It virtualizes product managers, architects, frontend designers, and hardcore backend developers in the terminal, letting LLMs work for you in a team format.

2. Architectural Subversion: Thin Harness, Fat Skills

To achieve this "team-based" collaboration, the traditional approach is to write an extremely massive, rigid Agent framework (Fat Framework). But Garry explicitly points out this is a huge mistake: "LLMs are already smart enough; overly heavy scaffolding will only constrain their potential."

GStack proposes a completely new design philosophy: "Thin Harness, Fat Skills."

Thin Harness: The underlying scheduler of the system is very lightweight. It only does one thing—maintains the current context in the terminal and hands over the task to the next role at the right time.
Fat Skills: The real magic lies in the "skill packages" mounted on it. In Garry's demo, each Skill is not a simple API call, but a Domain Specialist with an independent persona and massive internal logic.

This loosely coupled architecture allows you to hot-plug different "digital employees" into the terminal at any time according to your needs.

3. Stage One: The Office Hours Skill (Reshaping the Product's Soul)

In the demo, Garry wants to build a small app to "automatically extract 1099 tax forms from Gmail for users during tax season."
If we followed the old way, we would throw this requirement directly to Claude and let it start writing Gmail API scraping code.

But in GStack, Garry first calls a skill named Office Hours.

This is the most mind-blowing part of the entire video. This skill package encapsulates the soul of 16 top Y Combinator partners coaching founders for tens of thousands of hours. It doesn't start writing code at all; instead, like a picky investor, it continuously throws 6 oppressive "Forcing Questions" at Garry:

"What is your strongest evidence that anyone actually wants this?"
"TurboTax already exists, and Plaid can connect directly to banks. Why do you think they need your little tool?"

It doesn't just ask questions; it actively helps the founder iterate the business model.
After multiple rounds of dialogue, this virtual YC partner proposes: "Don't just build a tool to help people download files. We need to use 'finding tax forms' as a Wedge Strategy. The real business model is to funnel the users who have downloaded their tax forms to professional CPAs (CPA Marketplace) and take a cut from it!"

This is the power of "Fat Skills." At this stage, the LLM is not a code generator at all; it is a co-founder with extremely high business Taste. It helps you elevate a tool that can only be sold for $2 into a commercial platform that can charge 10x commission.

4. Stage Two: Adversarial Review

After the business model is finalized, the system enters the phase of writing the Product Requirements Document (PRD).
GStack once again demonstrates the essence of human team collaboration—Code Review and QA.

After generating the initial design document, the system automatically triggers multiple rounds of "Adversarial Review." Another Agent acting as a reviewer starts looking for flaws with a magnifying glass:

"Your design makes no mention of how to handle the 2FA (Two-Factor Authentication) callback."
"Missing privacy policy and sensitive data handling statement."
"Failure handling mechanism is missing."

The most terrifying thing is that after discovering the problems, the two LLMs start to fight each other in the terminal, automatically fixing these 16 pointed-out architectural vulnerabilities. Watching the two code streams flashing alternately in the terminal, a rough idea that originally only scored 6/10 points was forcefully polished into an 8/10 professional-grade technical specification without any human intervention.

5. Stage Three: The LLM Matrix (ADHD CEO and Autistic CTO)

In the visual UI design stage, GStack calls another skill named Design Shotgun.
Here, Garry throws out an extremely vivid and precise metaphor, revealing the true meaning of the LLM matrix:

"You can think of Claude Opus 4.6 as a creative CEO with ADHD. You'd love to grab a beer with him, and his head is full of a billion brilliant ideas and product definitions. But when it's time to actually bite the bullet on the extremely hardcore, boring code implementation, you have to call in the hardcore autistic CTO—and that's OpenAI's Codex model."

This is precisely the essence of GStack's underlying scheduling: No single model can do everything.
When discussing business models and user pain points, call Claude Opus, which is extremely good at empathy and product logic; and when generating specific UI components and underlying hardcore algorithms, the system will instantly and smoothly switch to OpenAI's model.

This practice of perfectly binding the personality traits (Persona) of different LLMs with specific development stages is the ultimate modularity we have always pursued when building the Agent OS.

6. Conclusion: The Age of Discovery for Solo-Founders

After watching Garry Tan's sci-fi-movie-like demonstration, we must admit a fact: The era of the monolithic engineer is over, and the Age of Discovery for Solo-Founders has officially begun.

When you can use a single command to instantly summon a top YC product partner, an extremely demanding QA architect, and a full-stack engineer who works all night without getting tired in the terminal, the marginal cost of software development has infinitely approached zero.

In this cruel dimensional strike, you don't need to write more elegant loop statements than others. The only things you need to possess are the Taste, Vision, and the Audacity to reshape all old rules as the supreme commander.

The CLAUDE.md File That 10x'd My Output

Hunter G — Wed, 29 Apr 2026 20:57:07 +0000

Why do some developers feel like they have superpowers when using AI coding tools, while others feel like they are babysitting an intern?

If you use Cursor or Claude Code, you've probably noticed a frustrating pattern. One day the AI writes brilliant code. The next day, it forgets your project's architecture, uses the wrong UI library, and writes messy boilerplate code that you explicitly hate.

You end up wasting hours correcting the AI. This is because LLMs are not lacking intelligence. They are lacking "Project Memory."

The Hidden Ground Truth

In the underlying mechanics of Claude Code, there is a powerful, almost tyrannical design feature. Every single time you start a new session, before you type your first prompt, the AI quietly looks for a hidden file in your root directory.

That file is CLAUDE.md.

For normal developers, this is just a readme file. But for top 1% hackers, this is a neural link to force-feed an entire persona and project memory into the LLM.
This file acts as the absolute Ground Truth. Let's break down exactly how to construct a 10x CLAUDE.md file.

1. Persona and Vibe

Do not let the AI act like a generic, polite assistant. Set the stage immediately:
"You are a Senior Principal Engineer at a top-tier tech company. You write incredibly elegant, high-cohesion code. You despise boilerplate. Always prioritize performance."

2. Unbreakable Tech Stack Rules

Turn your team's development standards into unbreakable laws.
"Our frontend strictly uses React 18 functional components and Tailwind CSS. NEVER write a Class Component. NEVER write inline CSS. Our backend is locked to PostgreSQL."
With these hard limits, the AI will stop polluting your codebase with random, outdated libraries.

3. Global Architecture Map

Don't let the AI burn tokens blindly searching your folders. Tell it exactly where things live.
"All core orchestration logic lives in the /agents directory. State management is restricted to the /memory folder."

4. Hard-Learned Lessons

This is the most valuable section. Take your team's blood, sweat, and tears, and hardcode them into the AI's muscle memory.
"We tried using standard LangChain for memory, but it caused severe latency spikes. NEVER import LangChain. Always use our custom MemoryStore class."

Conclusion

In the Agent OS era, the boundary between human and machine is shifting. Writing a perfect CLAUDE.md is not just writing a prompt. You are compiling a digital brain.

Stop fighting with your AI over syntax errors. Build a CLAUDE.md file, inject your soul into it, and watch the AI dominate your codebase.

My Claude Code Can INSTANTLY Watch Any Video (Here's How)

Hunter G — Wed, 29 Apr 2026 19:58:26 +0000

Most AI video summary tools are completely blind. When you give them a 45-minute tech talk, they only extract the transcript.

If the speaker points to a retention graph and says "This is where startups die," the AI has no idea what "this" is. It misses the charts, the UI bugs, and the code snippets. In a multi-modal era, summarizing without visual context is useless.

The Local Hacker Solution

Anthropic doesn't have a native video model yet, and Gemini 1.5 Pro is expensive and hard to wire into Claude.

But a video is just two things: Frames (Images) + A Transcript (Text).

We can build an unstoppable pipeline using two battle-tested CLI tools:

yt-dlp: Instantly downloads the video stream and official free subtitles from over 1,000 sites.
ffmpeg: Silently extracts high-res frames every few seconds.

If a video lacks captions, we use Grok or OpenAI's Whisper API to transcribe the audio for pennies.

How it works

The script extracts roughly 100 keyframes from the video (dynamically scaling the interval so it never blows up your token window). It pairs these frames with the timestamped transcript and feeds it all into Claude.

Within 2 minutes, Claude has "watched" the entire video. The total token cost for a 45-minute video? About $1.

3 Killer Use Cases

Content Research: Drop a competitor's viral video and ask Claude to analyze the visual hook and script simultaneously.
UI Debugging: Feed a 30s screen recording of a frontend crash and ask Claude to pinpoint the exact frame the Z-index state changed.
Automating the Second Brain: Run this over industry podcasts and push structured, charted notes directly into your Obsidian vault.

Stop paying for expensive AI wrappers. Wire up your CLI and let your LLM grow eyes.

YC CEO Rebuilt a $10M Startup in 3 Weeks: Why Your Agent Framework is Wrong

Hunter G — Fri, 24 Apr 2026 18:21:00 +0000

Y Combinator CEO Garry Tan recently dropped a bombshell demonstration. Using his open-source GStack framework, he single-handedly rebuilt a startup that originally took 2 years and 10 engineers to build—in just 3 weeks.

If you are building AI Agents, you need to pay attention. He proposed a radical architectural philosophy: "Thin Harness, Fat Skills."

1. The Myth of the "Fat Framework"

Most developers try to build massive, rigid Agent frameworks. Garry argues this is a mistake. The underlying LLMs are already smart; heavy scaffolding only constrains them.

Instead, GStack uses a "Thin Harness": A lightweight CLI that simply maintains terminal context and orchestrates handoffs.
The magic lies in "Fat Skills": High-context, persona-driven domain experts that you plug into the terminal.

2. The "Office Hours" Skill: AI as a Co-Founder

Before writing a single line of code, GStack runs the Office Hours skill. This agent encapsulates the soul of YC partners. It interrogates the founder with forcing questions:

"What is your strongest evidence that anyone wants this?"
"TurboTax already exists. Why you?"

In the demo, the AI actively pushed Garry to pivot his business model from a $2 tool into a highly profitable CPA marketplace funnel. The AI wasn't a code generator; it was a co-founder with elite business Taste.

3. Adversarial Review: Machines Arguing

Once the PRD is drafted, two agents engage in an "Adversarial Review". They ruthless debate the architecture.

"You missed 2FA handling."
"There is no failure handling here."

Watching the terminal blink as two models automatically catch and patch 16 architectural vulnerabilities without human intervention is the ultimate display of the Agent OS.

Conclusion: The Solo-Founder Era

The marginal cost of software development is approaching zero. You no longer need to be the best syntax writer. To win in this new era, you only need three things: Taste, Vision, and Audacity.

Stop Fighting Amazon Captchas: We Open-Sourced a Billion-Row Data Plugin

Hunter G — Sun, 19 Apr 2026 17:30:52 +0000

In today's e-commerce landscape, the true barrier to AI is no longer the model itself—it's access to clean, comprehensive data.

Over the last year, Amazon's anti-scraping and captcha mechanisms have become incredibly strict. Whether you are writing a custom scraper or paying for expensive monitoring SaaS, everyone faces the same issue: IP bans, missing data, and polluted datasets.

If your data source is blocked or compromised, even the best Prompt Engineering is useless.

The Industry's Exclusive Data Vault

To solve the problem of data scarcity, we have accumulated billions of real, structured Amazon reviews across all categories over the years.

This isn't just a database; it's a massive, cleaned, and labeled "Data Goldmine". If you can access this vault, every buyer pain point, product defect, and usage scenario is laid bare.

1-Click Deployment: The Open Source VOC AI Plugin

Today, we are handing you the keys to the vault. We have officially open-sourced our voc-amazon-reviews plugin.

This isn't a complex scraper that requires you to buy expensive proxy pools. It's an incredibly lightweight, easy-to-deploy CLI plugin.

Installation

You can install it directly from GitHub with one line:

clawhub install mguozhen/voc-amazon-reviews

Accessing the Billion-Row Vault

Once installed, just run:

clawhub run voc-amazon-reviews --asin B099Z93WD9

The plugin bypasses the entire scraping process. It connects directly to our underlying data vault and outputs clean JSON and deep LLM semantic insights within 5 seconds.

👉 GitHub Repo: voc-amazon-reviews

Stop fighting captchas. Tap into the industry's most exclusive data artery today.

The Agent OS: Why Building 'Role Agents' is Better Than Empowering Individuals

Hunter G — Sat, 18 Apr 2026 10:06:29 +0000

A16Z recently published an incredibly harsh reality check: AI made every individual 10x more productive, but no company became 10x more valuable as a result.

Why? Because we are treating AI like a faster electric motor in a 19th-century steam engine factory. We swapped the engine, but we haven't redesigned the assembly line.

If you want to build an AI-Native Organization, you must shift from "Individual AI" to "Institutional AI".

1. Package "Role Agents", Don't Just Empower "Individuals"

This is the fundamental difference. The old instinct was "give everyone a ChatGPT." This creates massive organizational chaos—everyone uses different prompts and formats, leading to disastrous bottlenecks when aggregating data.

True organizational capability comes from building a matrix of "Role Agents," rather than just giving everyone an assistant.

A qualified Role Agent must encapsulate three elements:

Taste: The aesthetic and quality standard of the role.
Skill: Private toolkits and execution capabilities.
Memory: The company-level historical context of that position.

When you deploy a digital employee matrix built on these three pillars, they coordinate natively. You are upgrading the "Standard Asset of the Position", instead of relying on an employee's extraordinary performance.

2. Find Signal, Stop Generating Noise

Generating a 10,000-word report now costs nothing. This means "Information Slop" is rising exponentially.
Institutional AI is not a generator; it is a filter. It acts as a cold auditor, picking out the one critical data point from 1,000 logs that impacts tomorrow's revenue.

3. Scale Revenue, Don't Just Save Time

Saving an employee 2 hours a day is not an asset. Institutional AI scales the revenue ceiling. It shifts employees from "executors" to "reviewers."

Organization is not managed; it is designed. Are you going to keep installing faster motors, or are you ready to redesign the factory?