Forem: Siddhesh Surve

🚀 The "Vibe Coding" Era is Over: What AI Founders Are Building Instead

Siddhesh Surve — Tue, 05 May 2026 02:56:48 +0000

If you’ve been paying attention to the venture capital space, you likely caught Ann Miura-Ko’s latest insights making the rounds on X. The message from top-tier Silicon Valley investors is becoming incredibly clear: the days of hacking together a thin UI over an OpenAI API key and calling it a disruptive startup are coming to a hard stop in 2026.

Founders are being pushed to build Minimum Viable Companies, not just Minimum Viable Products. The market is completely saturated with basic AI wrappers. What is actually getting funded and gaining real traction right now? Deep, infrastructural utility.

Here is exactly how the engineering meta is shifting, and what you should be focusing on if you want to build something that lasts.

1. 🛑 Stop Building Wrappers, Start Building Workflows

The first wave of generative AI was all about generation. The next wave is all about orchestration. Users don't want another chatbot sitting in a browser tab; they want autonomous systems that remove entire categories of work from their plates.

If your application just takes user text, sends it to an LLM, and prints the result, you don't have a technical moat. You have a feature that will inevitably be sherlocked by the platform providers themselves.

2. 🏗️ The Move to Agentic Infrastructure

Instead of simple request-response cycles, successful products are moving toward agentic infrastructure. This means your code needs to handle state, memory, error recovery, and tool execution in the background.

Developing the secure-pr-reviewer GitHub App and deploying it to production on Railway back in January 2026 required exactly this kind of architectural shift. It wasn't enough to just send raw code snippets to an API. Building it required a robust TypeScript and Node.js backend to listen for webhooks, parse the abstract syntax tree of the repository, run the AI security audit, and intelligently comment back on the exact lines of code inside the pull request.

Here is a simplified look at how that kind of event-driven, agentic infrastructure is structured in Node.js:

import { Probot } from "probot";
import { analyzeCodeSecurity } from "../services/ai-auditor";

export default (app: Probot) => {
  app.on(["pull_request.opened", "pull_request.synchronize"], async (context) => {
    const prDetails = context.pullRequest();

    // Fetch the actual diff to provide context, not just a raw prompt
    const { data: diff } = await context.octokit.pulls.get({
      owner: prDetails.owner,
      repo: prDetails.repo,
      pull_number: prDetails.pull_number,
      mediaType: { format: "diff" },
    });

    context.log.info(`Initiating security audit for PR #${prDetails.pull_number}`);

    // The AI service handles the deep reasoning and logic assessment
    const securityReport = await analyzeCodeSecurity(diff);

    if (securityReport.vulnerabilitiesFound) {
      const reviewComment = context.issue({
        body: `### 🛡️ Automated Security Audit\n\n${securityReport.markdownSummary}`,
      });
      // Agent autonomously injects its findings into the human workflow
      await context.octokit.issues.createComment(reviewComment);
    }
  });
};

This is where the massive value lies: taking a complex, multi-step human workflow (like reviewing a PR for security vulnerabilities) and automating it entirely in the background so the engineering team doesn't even have to think about it.

3. 📉 The Rise of the "Micro-Team"

Because AI is handling so much of the boilerplate scaffolding and testing, we are seeing the rise of hyper-efficient micro-teams. You don't need a massive engineering pod to ship a scalable MVP anymore. You need one or two deeply technical founders who understand systems architecture and can leverage AI to write the functional components.

But this requires a solid understanding of fundamental computer science. If you let the AI write the code, you still have to design the system.

💡 The Takeaway

The barrier to building software has dropped to zero, which means the baseline expectations for a startup have skyrocketed. As investors point out, the market is looking for true substance and organic product-market fit.

To win in 2026, stop optimizing your prompts and start optimizing your architectures. Build systems, build workflows, and build real companies.

What are you building right now? Are you seeing this same shift away from simple AI wrappers in your own circles? Let's discuss in the comments below!

🚨 The "Context Window" is Dead: Anthropic Just Gave Claude Agents Permanent Memory

Siddhesh Surve — Tue, 28 Apr 2026 02:32:24 +0000

If you’ve been building with AI over the last year, you know the absolute biggest bottleneck in agentic engineering: The Goldfish Problem.

You spend hours crafting the perfect system prompt. You deploy your AI agent to handle a complex task. It does a great job. But the second that session ends? Poof. The agent forgets everything.

To fix this, developers have been duct-taping together complex Vector DBs, RAG pipelines, and rolling context windows just to give their agents a basic sense of object permanence. It is exhausting, expensive, and fragile.

But as of this week, the game has completely changed. Anthropic just launched Memory for Claude Managed Agents in public beta, and it fundamentally shifts how we will build autonomous systems.

Here is everything you need to know about the update, why it's better than standard RAG, and how to implement it in your code today. 👇

🧠 What is Claude Agent Memory?

Unlike standard chatbot interactions where context is lost when the window closes, Anthropic’s new Memory feature allows Claude Managed Agents to accumulate knowledge across different sessions over time.

But here is the truly brilliant part: It is a filesystem-based layer.

Data isn't just floating in a black-box vector space. Claude stores its memories as actual files. This means your agents can read, write, and reference a continuous state, while you (the developer) maintain absolute programmatic control over what is being stored. Early enterprise adopters like Netflix and Rakuten are already using it to automate complex, long-running workflows without constantly having to update manual prompts.

🛡️ The "Audit Trail" Superpower

If you are building tools for enterprise, standard RAG pipelines are a compliance nightmare. If an AI hallucinates or leaks data, figuring out why it retrieved that specific piece of information is incredibly difficult.

Anthropic designed this new memory system with enterprise governance built-in:

Full Auditability: Every single memory change is logged.
Granular Control: You have an audit trail for each session and agent.
Rollbacks: You can programmatically roll back, redact, or delete specific memories if the agent learns something incorrect or sensitive.

💻 Building a "Smart" PR Reviewer in TypeScript

To understand how powerful this is, let's look at a real-world scenario.

Imagine you are building a production-ready GitHub App—let's call it secure-pr-reviewer—using TypeScript and Node.js.

Without memory, your AI reviewer treats every single Pull Request in a vacuum. It might flag the same internal, safe utility function as a "security risk" 100 times, infuriating your senior engineers who have to manually dismiss the warning every time.

With Claude's new Memory API, the agent learns from the team. If a senior dev tells the agent, "This auth pattern is expected in the legacy module," the agent remembers it for the next PR.

Here is what the implementation logic looks like using the new Managed Agents API paradigm:

import Anthropic from '@anthropic-ai/sdk';

const anthropic = new Anthropic({
  apiKey: process.env.ANTHROPIC_API_KEY,
});

// Assume this webhook fires when a new PR is opened
export async function handlePullRequestEvent(prData: any) {
  console.log(`[secure-pr-reviewer] Auditing PR #${prData.number}...`);

  // 1. Initialize or resume a Managed Agent Session with Memory enabled
  const session = await anthropic.beta.agents.sessions.create({
    agent_id: process.env.CLAUDE_SECURITY_AGENT_ID, // Your pre-configured agent
    memory: {
      enabled: true,
      scope: `repo-${prData.repository.name}`, // Scope memory to this specific repo
    }
  });

  // 2. Send the PR diff to the agent
  const response = await anthropic.beta.agents.messages.create({
    session_id: session.id,
    messages: [
      { 
        role: 'user', 
        content: `Audit the following diff for security flaws. 
                  Remember our past conversations about approved legacy patterns.
                  \n\n${prData.diff}` 
      }
    ]
  });

  // The agent uses its filesystem memory to check past developer feedback
  // before generating the final report.

  if (response.content.includes("VULNERABILITY_FOUND")) {
     await postGitHubComment(prData.number, response.content);
  }
}

If a developer replies to the bot's comment on GitHub saying, "Ignore this specific file path in the future, it's a mock database for testing," you simply pass that message back into the session. Claude writes that rule to its memory layer, and it will never flag that file again.

No database schemas to update. No RAG pipeline to re-index. The agent just gets smarter.

🚀 The Era of Stateful AI

We are officially moving from stateless functions to stateful, autonomous teammates. By providing a transparent, auditable, filesystem-based memory layer, Anthropic is removing the biggest friction point for enterprise AI adoption.

The feature is available in public beta right now via the Claude Console and APIs.

Are you going to rip out your custom Vector DBs and switch to native Agent Memory? Let me know what you think of the update in the comments below! 👇

If you found this breakdown helpful, drop a ❤️ and bookmark the code snippet for your next agentic side project!

🚀 The "Custom GPT" is Dead: OpenAI Just Dropped Workspace Agents (And They Run in the Background)

Siddhesh Surve — Fri, 24 Apr 2026 02:17:19 +0000

If you’ve spent any time tinkering with AI over the last year, you’ve probably built a Custom GPT. You give it a system prompt, maybe upload a PDF or two, and use it as a highly specific, personalized chatbot.

But there was always one fatal flaw with this workflow: Custom GPTs are entirely reactive. They only work when you are actively sitting at your keyboard, typing prompts, and waiting for a response.

That era officially ended today.

OpenAI just announced Workspace Agents in ChatGPT. Powered by their underlying Codex engine, these are not chatbots. They are autonomous, cloud-hosted agents that run in the background, execute multi-step workflows, and operate across your team's tools even after you close your laptop.

Here is why this completely changes how we build enterprise automation, and what you need to know to start using it today. 👇

🤯 From Chatbots to Background Daemons

The biggest shift with Workspace Agents is the decoupling of the AI from the traditional chat interface.

Because these agents run in the cloud, they have continuous memory and persistent execution. You don't have to manually prompt them to start working. You can configure an agent to run on a set schedule (e.g., "Pull Jira metrics every Friday at 4 PM and draft a report"), or deploy them directly into communication tools like Slack.

For instance, an agent deployed in a Slack workspace can proactively monitor incoming messages, route product feedback, answer documentation questions, and autonomously file IT tickets while your engineering team focuses on deep work.

💻 The Code: Automating the Automators

To understand how massive this is for developers, think about how we traditionally build workflow automation.

When I was architecting the secure-pr-reviewer GitHub App, the infrastructure overhead required just to get an AI to act autonomously was significant. To automatically review code, you have to spin up a Node.js server, use a framework like Probot to listen for webhooks, manually orchestrate the API calls to the LLM, and handle the asynchronous callbacks.

The Traditional Automation Stack (TypeScript):

import { Probot } from "probot";
import { runSecurityAudit } from "./ai-service";

export default (app: Probot) => {
  // 1. Listen for specific platform events
  app.on("pull_request.opened", async (context) => {

    // 2. Extract the context manually
    const diff = await context.octokit.pulls.get({
      owner: context.repo().owner,
      repo: context.repo().repo,
      pull_number: context.payload.pull_request.number,
    });

    // 3. Orchestrate the LLM call and wait for completion
    const securityReport = await runSecurityAudit(diff.data.body);

    // 4. Push the formatted result back to the platform
    const comment = context.issue({
      body: `🛡️ Security Audit Complete: \n${securityReport}`,
    });

    await context.octokit.issues.createComment(comment);
  });
};

With Workspace Agents, this entire middleware layer evaporates.

Instead of writing and hosting webhook listeners, you create a shared agent, grant it access to your integrations, and define the workflow in plain English: "Monitor new PRs in this repository. When opened, read the diff, check against our security guidelines, and post a comment with your findings." The Codex-powered agent handles the event listening, the context window management, and the API execution natively in the cloud.

🛑 The "Human-in-the-Loop" Safeguards

Of course, giving an autonomous agent unmitigated access to your CRM, codebase, or email inbox is terrifying for any enterprise.

OpenAI clearly anticipated this security anxiety. Workspace Agents come with strict, granular governance. For sensitive actions—like executing a database script, sending an outbound email to a client, or modifying a financial spreadsheet—the agent will automatically pause its execution and ping you for permission.

It does 99% of the heavy lifting, formats the data, and then essentially asks: "Does this look right before I hit send?" ## 💸 Availability & The Road Ahead

Right now, Workspace Agents are rolling out in research preview for ChatGPT Business, Enterprise, Edu, and Teachers plans.

Here is the kicker: They are completely free to use until May 6, 2026. After that date, OpenAI is shifting them to a credit-based pricing model, a logical move given that running persistent background daemons requires significantly more compute than standard, isolated chat completions.

We are rapidly moving away from "AI as an autocomplete tool" and entirely into the era of "AI as an asynchronous teammate."

I will be doing a complete, hands-on teardown of how to build and deploy these specific agents over on the AI Tooling Academy channel soon, so stay tuned.

Are you ready to let a cloud-hosted agent manage your Slack channel and codebase, or are the security risks still too high? Let me know your thoughts in the comments below! 👇

If you found this breakdown helpful, smash the ❤️ button and bookmark this post so you remember the May 6th pricing deadline!

🚀 Qwen 3.6 Max Preview is Here: Why Your AI Coding Agents Are About to Get a Massive Upgrade

Siddhesh Surve — Wed, 22 Apr 2026 02:20:11 +0000

If you've been building AI-driven workflows lately, you know the struggle. You set up a sophisticated agent to review a pull request or refactor a legacy module, and halfway through the task, it "forgets" its own logic and hallucinates a broken solution.

Just weeks after dropping the impressive 3.6-Plus model, the team at Alibaba Cloud has quietly unleashed an early look at their true heavyweight: Qwen 3.6-Max-Preview.

For those of us building autonomous coding agents and complex backend systems, this isn't just an incremental update. This model is specifically engineered to fix the memory and logic bottlenecks in autonomous development.

Here is exactly why this release is a massive deal for the developer ecosystem—and how you can integrate its best new feature into your TypeScript apps today. 👇

🤯 The Benchmarks: Dominating Agentic Coding

Most models can write a Python script to reverse a string. Very few models can clone a massive repository, navigate the terminal, read the documentation, and successfully patch a bug without human intervention.

Qwen 3.6-Max-Preview was built for the latter. According to the release notes, it has taken the absolute top score on six major coding benchmarks, including:

SWE-bench Pro * Terminal-Bench 2.0 (+3.8 over the already excellent 3.6-Plus)
SkillsBench (A massive +9.9 jump)
NL2Repo (+5.0)

What this translates to in the real world is an AI that has a vastly superior grasp of world knowledge and instruction following. It doesn't just guess what your codebase does; it logically traces the execution paths.

🧠 The Secret Weapon: `preserve_thinking`

When I'm building automated tools (like a Probot app for CI/CD or a webhook-driven PR reviewer), the biggest issue with LLMs is "context amnesia" during multi-step reasoning.

Qwen 3.6-Max-Preview supports an incredibly powerful API parameter: preserve_thinking.

When you enable this, the model retains the internal "thinking" content from all preceding turns in a conversation. It doesn't just remember what it said; it remembers how it arrived at that conclusion. For agentic tasks where the AI needs to iteratively debug a problem, this feature is the difference between an endless hallucination loop and a merged pull request.

💻 How to Use It in TypeScript

Because Alibaba's Model Studio provides a fully OpenAI-compatible endpoint, migrating your existing Node.js/TypeScript agents to Qwen 3.6-Max-Preview is as simple as changing the Base URL and passing the custom parameters.

Here is a quick example of how you can wire up an autonomous agent that utilizes persistent reasoning:

import OpenAI from 'openai';

// 1. Point your client to the DashScope compatible endpoint
const client = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY, 
  baseURL: '[https://dashscope-intl.aliyuncs.com/compatible-mode/v1](https://dashscope-intl.aliyuncs.com/compatible-mode/v1)',
});

async function runAutonomousAudit(codeDiff: string) {
  console.log("🚀 Booting up Qwen 3.6-Max Agent...");

  const response = await client.chat.completions.create({
    model: 'qwen3.6-max-preview',
    messages: [
      { 
        role: 'system', 
        content: 'You are an elite senior engineer performing a complex code audit.' 
      },
      { 
        role: 'user', 
        content: `Analyze this diff and propose architectural improvements:\n\n${codeDiff}` 
      }
    ],
    // 2. Inject the Qwen-specific agentic parameters
    // @ts-ignore
    extra_body: {
      enable_thinking: true,
      preserve_thinking: true, // 👈 The holy grail for multi-step reasoning
    },
    stream: true,
  });

  // 3. Process the stream to separate the "Thinking" from the final "Answer"
  for await (const chunk of response) {
    const thinking = (chunk.choices[0].delta as any).reasoning_content;
    const answer = chunk.choices[0].delta.content;

    if (thinking) {
      // Print the model's internal logic in gray
      process.stdout.write(`\x1b[90m${thinking}\x1b[0m`); 
    }

    if (answer) {
      // Print the final output normally
      process.stdout.write(answer); 
    }
  }
}

🔮 What’s Next?

It's important to note that this is still a preview release. The model is under active development, and the Qwen team explicitly noted they are iterating to squeeze even more performance out of it before the official GA launch.

But if this is just the preview, the ceiling for open-weight and proprietary agentic models in 2026 is looking incredibly high. If you want to start building reliable, autonomous teammates instead of just simple autocomplete scripts, Qwen 3.6-Max is demanding a spot in your tech stack.

You can test it interactively right now on Qwen Studio, or plug it directly into your apps via the API.

Are you making the shift toward autonomous coding agents this year? Let me know what you are building in the comments below! 👇

If you found this breakdown helpful, drop a ❤️ and bookmark the code snippet for your next weekend project! I'll be breaking down more of these enterprise AI tools over on the AI Tooling Academy channel soon.

🚀 Anthropic Just Dropped "Claude Design" (And It Changes Frontend Development Forever)

Siddhesh Surve — Tue, 21 Apr 2026 03:25:34 +0000

Let’s be real for a second. If you build software, you know the absolute most painful part of the development lifecycle isn't writing the business logic—it's the "mockup phase."

You have a great idea. You sketch it out. You wait for a designer to build it in Figma. You get a static JPEG. You realize the interactivity doesn't make sense. You send it back. Weeks pass before you even write your first npm install.

We are deep into 2026, and the speed of AI tooling is finally fixing this broken pipeline. Today, Anthropic Labs just released Claude Design, powered by their brand-new Opus 4.7 vision model.

I review a lot of workflow automation tools over on the AI Tooling Academy channel, but this one is genuinely a step-function improvement for engineering teams. It effectively bridges the massive gap between a product manager's rough idea and a developer's local codebase.

Here is why Claude Design is about to become a mandatory tool in your stack, and how it directly integrates with your coding environment. 👇

🤯 What is Claude Design?

At its core, Claude Design is an interactive, multi-modal canvas. You don't just prompt it for an image; you collaborate with it to create polished, fully interactive UI prototypes, slide decks, and marketing assets.

But it’s not just a generic UI generator. Anthropic built this explicitly to integrate into real-world enterprise engineering workflows.

🎨 1. It Auto-Ingests Your Codebase's Design System

The biggest problem with AI-generated UI is that it always looks like... well, AI-generated UI. It never matches your company's actual brand.

During onboarding, Claude Design actually reads your existing codebase and design files. It extracts your typography, CSS variables, color hexes, and React components to build a custom design system. Every prototype it generates from that point forward automatically uses your company's exact styling.

⚙️ 2. "Handoff to Claude Code" (The Killer Feature)

This is the feature that made my jaw drop.

Traditionally, translating a design into code means staring at a screen, measuring pixel padding, and writing tedious CSS. Claude Design introduces a Single-Instruction Handoff.

Once your team is happy with the interactive prototype in the canvas, Claude packages the entire project into a "handoff bundle." You can then instantly pass this bundle to Claude Code (Anthropic's CLI agent) to implement the actual logic in your local repository.

Imagine this workflow:

Your PM creates a functional wireframe in Claude Design.
They export the bundle.
You open your terminal and run a command to let your local AI agent scaffold the exact React components:

# Speculative workflow based on the new Claude Code Handoff integration
$ claude --task "Implement the new billing dashboard using the handoff bundle" \
         --bundle ./claude-design-billing-bundle.zip

[Claude Code]: Reading handoff intent...
[Claude Code]: Extracting Opus 4.7 design specifications...
[Claude Code]: Generating src/components/BillingDashboard.tsx...
[Claude Code]: Applying local Tailwind configuration...
✅ Done! Your interactive prototype is now live in your codebase.

🎛️ 3. Dynamic Sliders and Inline Editing

Instead of writing endless follow-up prompts like "make the gap between the cards a little wider", Claude generates custom UI sliders and knobs on the fly. You can literally drag a slider to adjust layout density, color saturation, or typography scaling in real-time, and Claude handles the underlying CSS updates instantly.

🌐 4. The Web Capture Tool

If you want to build a new feature on top of your existing production site, you don't need to rebuild the layout from scratch. You can use Claude Design's web capture tool to grab elements directly from your live website, pulling them into the canvas so your new prototype sits perfectly within your real product's UI.

🤝 The Canva Integration

For the founders and full-stack devs who also have to play marketer, Anthropic announced a massive integration with Canva.

If you use Claude Design to generate a pitch deck, a one-pager, or social media assets, you can export them directly into Canva with a single click. The assets remain fully editable and collaborative, meaning you can do the heavy conceptual lifting with Claude's reasoning, and the final polish in a tool your marketing team already knows how to use.

🎯 The End of the Static Mockup

The days of handing a static image to a developer and saying "make it work" are officially over.

With models like Opus 4.7 driving the vision and reasoning, we are moving to a world where prototypes are inherently interactive, code-aware, and tied directly to your CLI agents. Tools like this allow us to stop acting as human CSS translators and get back to focusing on high-level architecture and complex systems logic.

Claude Design is rolling out today in research preview for Claude Pro, Max, Team, and Enterprise subscribers.

Are you going to test out the Claude Code handoff pipeline? How do you think this impacts the traditional UX/UI design role? Let me know your thoughts in the comments below! 👇

If you found this breakdown helpful, drop a ❤️ and a 🦄! Bookmark this post to keep the workflow handy for your next sprint.

🔥 Google Just Leaked Its "Desktop Agent" (And It Changes How We Build Software)

Siddhesh Surve — Wed, 15 Apr 2026 02:50:32 +0000

For the last two years, the tech industry has been stuck in a loop. We open a browser tab, paste a block of code into a chatbot, copy the fixed code, and paste it back into our IDE. It's incredibly helpful, but let's be honest: it is still highly manual. The era of the "reactive chatbot" is officially dying. We are entering the era of the autonomous workspace.

According to massive new leaks reported by TestingCatalog, Google is quietly testing a brand-new "Agent" tab inside Gemini Enterprise, and it looks like a direct, aggressive strike against Anthropic's Claude Cowork and OpenAI's upcoming Codex Superapp.

If you lead an engineering team or build automated workflows, this is the paradigm shift you need to prepare for before Google I/O. Here is a breakdown of the leak, the new features, and what it means for your daily dev routine. 👇

🤯 The Shift: From Chat to "Task Execution Workspace"

The leak reveals that Gemini is moving away from a simple text input box. The new Agent area features an "Inbox" and a "New Task" UI that fundamentally restructures how the AI operates.

When you configure a new agentic task, the right-hand panel gives you granular control over:

Goal: The overarching objective (e.g., "Audit all incoming pull requests for security flaws").
Agents: Which specific sub-models or personas to deploy.
Connected Apps: Direct integrations into your enterprise stack (GitHub, Jira, Google Workspace).
Files: Contextual data access.
Require Human Review: The absolute killer feature (more on this below).

This isn't an assistant you chat with. This is a background daemon that executes multi-step workflows.

💻 The Code: How Agents Replace Middleware

To understand why this is a massive deal, let's look at how we currently build automation.

Let's say you built a GitHub App using TypeScript and Probot (something like secure-pr-reviewer) to automatically scan incoming PRs. Currently, your Node.js server has to manually catch the webhook, parse the diff, send it to an LLM, wait for a response, and post the comment back to GitHub.

The "Old" Way (Manual Orchestration):

import { Probot } from "probot";
import { analyzeDiff } from "./llm-service";

export default (app: Probot) => {
  app.on("pull_request.opened", async (context) => {
    // 1. Fetch the code diff manually
    const prDiff = await context.octokit.pulls.get({
      owner: context.repo().owner,
      repo: context.repo().repo,
      pull_number: context.payload.pull_request.number,
    });

    // 2. Wait for the LLM to process it
    const securityReport = await analyzeDiff(prDiff.data.body);

    // 3. Post the comment back to the repo
    const issueComment = context.issue({
      body: `🛡️ Security Audit: \n${securityReport}`,
    });

    await context.octokit.issues.createComment(issueComment);
  });
};

The Google Agent Way:
With the new Gemini Desktop Agent infrastructure, you wouldn't write this middleware at all.

You would simply connect the Gemini Agent to your GitHub repository via "Connected Apps," set the Goal to "Monitor new PRs and post a security audit," and let the autonomous agent handle the webhook listening, parsing, and posting entirely in the background. It reduces thousands of lines of boilerplate infrastructure into a single visual workflow.

🛑 The "Require Human Review" Toggle

When you are managing a team of engineers working on high-stakes, big data infrastructure, you cannot simply let an AI merge code or execute database migrations autonomously. Hallucinations happen.

This is why the "Require Human Review" toggle spotted in the leak is the most critical feature for enterprise adoption.

It proves Google is building for serious engineering environments. The agent can do 99% of the heavy lifting—running the tests, drafting the code, preparing the deployment—but it halts at the final execution step, pinging your "Inbox" for a manager or tech lead to click "Approve."

🖥️ The Desktop App Invasion

The leak strongly points toward Google rolling this out as a native Desktop App.

Why a desktop app? Because web browsers are sandboxed. If an AI agent is going to truly assist you, it needs native file system access, terminal control, and the ability to run local scripts. By bringing Gemini natively to the desktop, Google is preparing to fight OpenAI and Anthropic for the ultimate prize: owning your entire local development environment.

🎯 What's Next?

With Google I/O just around the corner, the timing of this leak is no coincidence. The big tech giants are no longer competing on who has the smartest conversational model; they are competing on who can build the most reliable, autonomous robotic employee.

Will this replace your IDE, or just sit alongside it? We'll find out soon. I'll be doing a complete, hands-on deep dive into setting up these exact automated workflows over on the AI Tooling Academy channel the second this drops, so stay tuned.

Are you ready to let an autonomous Google agent take over your background tasks, or are you keeping your automated scripts tightly controlled in-house? Let me know in the comments below! 👇

If you found this breakdown helpful, drop a ❤️ and a 🦄! Bookmark this post to keep the Probot reference handy for your next side project.

❄️ OpenAI’s Secret “Codex Superapp” Just Leaked: The End of Standalone ChatGPT?

Siddhesh Surve — Tue, 14 Apr 2026 02:19:29 +0000

If you are a developer, your current workflow probably looks a bit like this: You have a tab open for ChatGPT, a dedicated AI code editor, a browser window for documentation, and a terminal for executing scripts. Context switching isn't just killing your productivity; it’s fragmenting your AI’s "memory."

But according to new leaks discovered in the latest Codex client, OpenAI is preparing to nuke this fragmented workflow entirely.

They are quietly building a unified "Codex Superapp" designed to swallow ChatGPT, the Atlas browser, and your coding tools into a single, omnipotent desktop platform. And more importantly, they are introducing features that turn the AI from a simple chatbot into an autonomous, background-running teammate.

Here is a breakdown of the massive leaks, the highly anticipated "Scratchpad" feature, and why this fundamentally shifts how we will build software. 👇

📝 1. The "Scratchpad": True Parallel Execution

Until now, conversing with an AI has been strictly linear. You ask a question, you wait for the stream to finish, you ask the next question.

The leak reveals a new experimental UI called Scratchpad. Instead of a single chat thread, Scratchpad functions like an interactive TODO list where you can spin up multiple Codex tasks simultaneously.

Think about the implications here. Instead of sequentially prompting your AI to scaffold a project, you can drop a master prompt into the Scratchpad, which then spawns parallel agentic threads. One thread writes the database schema, another drafts the API routes, and a third writes the unit tests—all executing at the exact same time.

🫀 2. The "Heartbeat" System & Managed Agents

This is where things get wild. Code references within the Codex client reveal a new "Heartbeat" infrastructure.

In distributed systems, a heartbeat is used to maintain persistent connections with long-running, autonomous tasks. OpenAI is building native support for Managed Agents.

Instead of waiting for you to hit "Enter," these background agents can operate autonomously, execute multi-step workflows, and periodically "check in" (the heartbeat) to report progress or ask for human intervention.

To put this in perspective, imagine you are building a tool like a secure-pr-reviewer GitHub App in TypeScript. Currently, your Node.js backend has to manually orchestrate sequential API calls to analyze diffs. In a Managed Agent future, your code simply delegates the entire job to a background autonomous process:

// 🚀 Speculative API: Delegating to a Managed Agent Background Process
import { CodexAgent } from '@openai/codex-sdk';

export async function handlePullRequestEvent(payload: WebhookEvent) {
  if (payload.action !== 'opened') return;

  console.log(`[secure-pr-reviewer] Delegating PR #${payload.pull_request.number} to Codex Superapp...`);

  // Instead of waiting for a synchronous chat completion, 
  // we spin up a background agent with a 'heartbeat' connection
  const auditTask = await CodexAgent.createManagedTask({
    name: `PR_Security_Audit_${payload.pull_request.number}`,
    context: [payload.repository.full_name, payload.pull_request.diff_url],
    instructions: `
      1. Analyze the PR diff for security vulnerabilities (e.g., SQLi, XSS).
      2. If vulnerabilities are found, write a patch.
      3. Commit the patch to a new branch and draft a review comment.
    `,
    parallel_execution: true, // 👈 Utilizing the new Scratchpad logic
    onHeartbeat: (status) => {
      // The agent checks in autonomously without us polling
      console.log(`Agent Status: ${status.current_action} - ${status.percent_complete}%`);
    },
    onComplete: (result) => {
      console.log(`✅ Audit complete. Found ${result.issues_found} issues.`);
    }
  });

  return "Audit delegated successfully.";
}

With OpenClaw's founder recently joining OpenAI, and competitors like Anthropic developing their own desktop agent system (codenamed "Conway"), the race for true autonomous orchestration is escalating rapidly.

❄️ 3. Project "Glacier" (GPT-5.5?)

If an entirely new, unified desktop OS for AI wasn't enough, there is an intense rumor brewing alongside this leak.

Over the past few days, top OpenAI researchers have been cryptically posting snowflake emojis (❄️) across social media. Insiders speculate this is the codename for Glacier, widely believed to be the GPT-5.5 frontier model.

OpenAI has a history of coupling massive platform upgrades with new model releases to maximize the shockwave. Releasing a unified desktop Superapp powered by a model capable of orchestrating complex, parallel background tasks would be an absolute paradigm shift.

🎯 The Takeaway

We are rapidly moving from an era of "prompt engineering" to "agent orchestration." The developers who win the next decade won't be the ones writing boilerplate code; they will be the ones acting as tech leads for fleets of managed AI agents.

Given OpenAI's tendency for surprise drops, we could see the Codex Superapp launch in a matter of days.

Are you ready to give an AI persistent background access to your machine, or are we giving away too much control too fast? Drop your thoughts in the comments below! 👇

If you found this breakdown helpful, drop a ❤️ and bookmark this post! For more deep dives into building automated agentic workflows, make sure to check out my latest videos over at **AI Tooling Academy.

🚀 OpenAI's Secret "Image V2" Just Leaked on LM Arena: The End of Mangled AI Text?

Siddhesh Surve — Wed, 08 Apr 2026 02:43:07 +0000

If you've been using ChatGPT over the weekend and suddenly found yourself being asked to choose between two surprisingly high-quality image generations, congratulations—you might be an unwitting beta tester for OpenAI’s next major release.

According to a new report from TestingCatalog, OpenAI is quietly running a massive stealth test for its next-generation image generation model, internally dubbed "Image V2." If you build apps, design UIs, or generate commercial assets, this is a massive deal. Here is everything we know about the leaked model, the "code red" pressure from Google, and why this update might finally fix AI's biggest, most annoying flaw. 👇

🕵️‍♂️ The Arena Leak: What is "Image V2"?

Over the past few days, eagle-eyed users on the LM Arena (the premier blind-testing leaderboard for AI models) noticed three mysterious new image generation variants pop up:

packingtape-alpha
maskingtape-alpha
gaffertape-alpha

By the end of the weekend, the models were pulled from the Arena, but they are still heavily circulating inside ChatGPT under a strict A/B testing framework.

This is classic OpenAI. They used this exact same blind-testing playbook back in December 2025 with the "Chestnut" and "Hazelnut" models, which ended up shipping just weeks later as GPT Image 1.5.

🤯 The Holy Grail: AI That Can Actually Spell

So, why should developers and designers care? Because early impressions indicate that Image V2 has finally conquered the final boss of AI image generation: Realistic UI rendering and correctly spelled text.

Historically, asking an AI to generate a UI mockup or a marketing banner resulted in beautiful designs covered in alien hieroglyphics. Image V2 is reportedly delivering pixel-perfect button text, accurate typography, and an incredibly strong compositional understanding.

If you are a frontend developer, this means you can soon prompt ChatGPT to generate a complete, text-accurate landing page mockup, slice it up, and start coding—without having to mentally translate mangled letters.

🚨 The "Code Red" Counter-Attack

It's no secret that OpenAI has been feeling the heat. According to the report, OpenAI has been operating under a CEO-mandated "code red" since late 2025.

Why? Because Google's Nano Banana Pro and Gemini 3 models have been absolutely eating their lunch, dominating the top spots on the LM Arena leaderboard for months. Image V2 is OpenAI’s direct, aggressive answer to Google's visual dominance.

💻 What the API Might Look Like

While pricing and official release dates are still unannounced, history shows OpenAI usually drops the new models into their existing SDK within weeks of these Arena tests. GPT Image 1.5 already slashed API costs by 20%, so we are hoping for competitive pricing here.

When it does drop, integrating the new model into your Node.js apps will likely be a seamless drop-in replacement. Here is how you'll probably trigger the new high-fidelity UI generations:

import OpenAI from "openai";

const openai = new OpenAI({ apiKey: process.env.OPENAI_API_KEY });

async function generateUIMockup(promptText) {
  console.log("🎨 Generating UI Mockup with Image V2...");

  const response = await openai.images.generate({
    model: "image-v2", // 👈 The anticipated new model name
    prompt: `A modern, clean SaaS dashboard UI. 
             Sidebar on the left with navigation. 
             Main content shows a revenue chart. 
             A bright blue button in the top right that explicitly says "Export Data". 
             High fidelity, web design, vector style.`,
    n: 1,
    size: "1024x1024",
    quality: "hd", // Requesting maximum text clarity
  });

  const imageUrl = response.data[0].url;
  console.log(`✅ Success! View your mockup here: ${imageUrl}`);
  return imageUrl;
}

generateUIMockup();

🔮 The Verdict

The biggest question now is whether OpenAI will maintain the incredible raw quality seen in the Arena, or if they will dial it back with heavy safety filters and cost-optimizations before the public API launch.

Either way, the era of AI failing to spell basic words on a button is coming to an end.

Have you encountered any of the "tape-alpha" models in your ChatGPT sessions this week? Did the text actually make sense? Let me know what you generated in the comments below! 👇

If you found this breakdown helpful, drop a ❤️ and bookmark this post so you're ready to update your API calls the minute the model officially drops!

🚀 The "Legacy Code" Nightmare is Over: How AI Agents are Automating App Modernization

Siddhesh Surve — Tue, 07 Apr 2026 02:59:30 +0000

Let’s be honest for a second. If you’ve been a software engineer for more than a few years, you’ve probably inherited a "legacy monolith".

You know the one I'm talking about. The massive, 15-year-old codebase where business logic is hopelessly tangled with presentation layers, the original developers left a decade ago, and touching a single file breaks production.

Historically, when upper management says, "We need to move this to the cloud," developers groan. The process of migrating and modernizing apps—deciding whether to Rehost, Refactor, or Rebuild—is notoriously painful, expensive, and slow.

But the meta is shifting. Microsoft just released their highly anticipated App Modernization Playbook, and tucked inside the strategy guide is the absolute game-changer for 2026: Intelligent Agents.

We are no longer just using AI to write new code. We are deploying autonomous AI agents to audit, decouple, and refactor our old code. Here is how this is completely changing the modernization landscape. 👇

🛑 The Old Way: Manual Portfolio Audits

In the past, app modernization started with weeks of painful meetings. Engineers would have to manually audit dozens of applications, mapping out dependencies, and guessing the technical debt.

According to Microsoft's playbook, the hardest part isn't actually moving code to Azure or AWS—it’s deciding which apps matter most and what to do with them.

🤖 The New Way: Agentic Discovery & Execution

Instead of humans combing through thousands of lines of spaghetti code, organizations are now pointing AI Discovery Agents at their repositories.

These agents don't just read the code; they map out execution paths, identify unused endpoints, flag hardcoded credentials, and recommend the exact target architecture (e.g., Serverless, Containerization, or full Microservices).

💻 See It In Action: Breaking the Monolith

Let's look at a conceptual example. Imagine you have a massive, tightly coupled Express.js application.

The Before: The 10-Year-Old Monolith (server.js)

// 🍝 5,000 lines of tightly coupled spaghetti
app.get('/api/v1/orders', async (req, res) => {
   try {
       // Direct DB queries mixed with routing
       const data = await db.query('SELECT * FROM Orders O JOIN Users U ON O.userId = U.id WHERE U.id = ?', [req.query.userId]);

       // Legacy data mutation happening right in the controller
       const formattedData = data.map(order => ({ ...order, total: order.qty * order.price }));

       res.status(200).json(formattedData);
   } catch (err) {
       res.status(500).send("Database error");
   }
});

A human developer would spend hours decoupling the database logic, writing new unit tests, and moving this to a scalable microservice.

An AI Refactoring Agent can autonomously parse the Abstract Syntax Tree (AST), isolate the business logic, and generate the scaffolding for a modern, decoupled cloud function (like an Azure Function):

The After: Agent-Generated Microservice

// 🚀 1. The Agent extracts the logic into a Service Layer (orderService.js)
export async function getFormattedOrders(userId) {
    const data = await db.query('SELECT * FROM Orders O JOIN Users U ON O.userId = U.id WHERE U.id = ?', [userId]);
    return data.map(order => ({ ...order, total: order.qty * order.price }));
}

// 🚀 2. The Agent generates the Serverless Handler (index.js)
import { getFormattedOrders } from '../services/orderService.js';

export default async function (context, req) {
    context.log('⚡ Processing order request via Serverless function.');
    try {
        const orders = await getFormattedOrders(req.query.userId);
        context.res = { status: 200, body: orders };
    } catch (error) {
        context.log.error("Failed to fetch orders: ", error);
        context.res = { status: 500, body: "Error fetching orders" };
    }
}

The agent doesn't just rewrite the code; it re-architects it for the cloud, ensuring proper separation of concerns without over-engineering the solution.

📘 The Microsoft Playbook Strategy

The Microsoft App Modernization Playbook lays out a brilliant, structured approach for utilizing these agents:

Assess Value vs. Complexity: Use AI agents to scan your portfolio. High business value + low complexity? That's your easy win for refactoring. Low value + high complexity? Leave it as-is or retire it. Let the data drive the decision, not developer intuition.
Right-Size the Architecture: Don't default to Kubernetes for everything. Agents can analyze your traffic patterns and recommend Serverless (Azure Functions) for bursty traffic or Container Apps for consistent workloads.
Automate Execution: Once the plan is set, deploy execution agents to handle the tedious scaffolding, CI/CD pipeline generation, and initial refactoring passes.

🎯 The Takeaway

We are entering a golden age for developers where we no longer have to be digital archaeologists digging through terrible code from 2012. By leveraging intelligent agents for discovery, assessment, and execution, we can finally focus on building new features instead of constantly putting out legacy fires.

If you are currently staring down a massive migration project, I highly recommend checking out the full strategy guide. You can grab the free e-book and read the full breakdown directly from Microsoft right here: The App Modernization Playbook.

What do you think? Are you ready to let an AI agent loose on your company's oldest monolithic codebase, or is that a recipe for disaster? Let me know in the comments below! 👇

If you found this breakdown helpful, smash the ❤️ and 🦄 buttons, and bookmark this post for the next time your boss asks about moving to the cloud!

🚀 Qwen 3.6-Plus Just Dropped: The 1M-Context AI Changing the "Vibe Coding" Game

Siddhesh Surve — Sat, 04 Apr 2026 04:55:21 +0000

The AI coding landscape is moving so fast it's almost impossible to keep up. Just when we thought we had our agentic workflows dialed in, Alibaba Cloud dropped a massive update: Qwen 3.6-Plus.

If you've been relying on Claude Opus or GPT-4 for your autonomous coding agents, you need to pay attention to this release. Qwen 3.6-Plus is heavily optimized for "vibe coding" and repository-level problem-solving, and the benchmarks show it matching or beating industry heavyweights across the board.

Here is a breakdown of what makes this new model so powerful, and how you can integrate its killer new features into your own apps today. 👇

🧠 1 Million Context Window (By Default)

Let's start with the sheer size. Qwen 3.6-Plus ships with a 1M context window out of the box.

For everyday chat, this is overkill. But for autonomous agents? It's mandatory. This massive context allows you to dump entire codebases, API documentations, and massive log files into the prompt without worrying about truncation.

Combined with its improved spatial intelligence and multimodal reasoning, you can now feed the model UI screenshots alongside thousands of lines of code and ask it to wire up the frontend autonomously.

🛡️ The Killer Feature: `preserve_thinking`

When building my secure-pr-reviewer GitHub App, one of the biggest hurdles is "agent amnesia." When I feed the model a massive pull request containing complex TypeScript type definitions and Node.js backend logic, it needs to reason through the security implications. But historically, if the agent makes a multi-turn conversation (e.g., calling a tool, getting a response, and thinking again), it discards its previous internal "thinking" trace.

Qwen 3.6-Plus solves this with a brand new API parameter: preserve_thinking.

When enabled, the model actively retains the internal "thinking" content from all preceding turns in the conversation. This drastically improves decision consistency for complex, multi-step agentic workflows, ensuring the AI doesn't lose its train of thought when executing complex automated tasks.

💻 How to Use It (TypeScript Example)

Because Alibaba's Model Studio provides an OpenAI-compatible endpoint, integrating this into your existing Node.js stack is incredibly simple.

Here is how you can use the official openai SDK to tap into Qwen 3.6-Plus and enable persistent reasoning for your agents:

import OpenAI from 'openai';

// Point the standard OpenAI client to Alibaba's DashScope endpoint
const client = new OpenAI({
  apiKey: process.env.DASHSCOPE_API_KEY, 
  baseURL: '[https://dashscope-intl.aliyuncs.com/compatible-mode/v1](https://dashscope-intl.aliyuncs.com/compatible-mode/v1)',
});

async function runSecurityAudit(prDiff: string) {
  console.log("🔍 Booting up Qwen 3.6-Plus Agent...");

  const response = await client.chat.completions.create({
    model: 'qwen3.6-plus',
    messages: [
      { 
        role: 'system', 
        content: 'You are an autonomous security agent auditing code.' 
      },
      { 
        role: 'user', 
        content: `Please review the following PR diff:\n\n${prDiff}` 
      }
    ],
    // We pass the Qwen-specific features in the extra_body
    // @ts-ignore
    extra_body: {
      enable_thinking: true,
      preserve_thinking: true, // 👈 The magic toggle for agentic workflows
    },
    stream: true,
  });

  for await (const chunk of response) {
    // Qwen returns thinking logic under a custom property before the actual answer
    const thinkingDelta = (chunk.choices[0].delta as any).reasoning_content;
    const contentDelta = chunk.choices[0].delta.content;

    if (thinkingDelta) {
      process.stdout.write(`\x1b[90m${thinkingDelta}\x1b[0m`); // Print thinking in gray
    }

    if (contentDelta) {
      process.stdout.write(contentDelta); // Print final answer normally
    }
  }
}

🏆 The Benchmarks: A New Standard

If you are a numbers person, the benchmark data on Qwen 3.6-Plus is staggering.

On SWE-bench Verified, it scores a 78.8 (edging out Claude Opus 4.5 at 76.8). It also dominates in complex terminal operations, scoring a 61.6 on Terminal-Bench 2.0. Anthropic and OpenAI have dominated the "Coding Agent" narrative for the last year, but Qwen has officially entered the chat with an "all-rounder" model that organic integrates deep logical reasoning and precise tool execution.

🔮 What’s Next?

The API is available immediately via Alibaba Cloud Model Studio, and the team noted that it can be seamlessly integrated into popular open-source coding harnesses like OpenClaw and Cline.

As the AI models get smarter and context windows expand, we are rapidly moving away from "AI autocomplete" and fully into the era of "AI Coworkers".

Are you planning to test Qwen 3.6-Plus in your workflows? Drop your thoughts in the comments below! 👇

If you found this breakdown helpful, don't forget to hit the ❤️ and bookmark the code snippet for your next agentic weekend project!

🚀 Cursor 3 Just Dropped: Why "Agent Swarms" Are the New Meta for Developers

Siddhesh Surve — Sat, 04 Apr 2026 04:50:11 +0000

For the last year, we've all been experiencing the second era of AI software development. We moved from standard autocomplete to having an AI "copilot" in our IDEs. But honestly? It still required a lot of hand-holding. You had to micromanage your AI, keep track of endless chat contexts, and juggle multiple terminals just to ship a single feature.

That era is officially over.

The team at Anysphere just announced Cursor 3, and it fundamentally shifts the paradigm from "AI pair programmer" to an autonomous agent workspace.

Here is why Cursor 3 is an absolute game-changer for your engineering workflow, and how it completely redefines how we interact with codebases. 👇

🤯 Rebuilt from the Ground Up

When Cursor first launched, it was essentially a highly optimized fork of VS Code. It was great, but it was still constrained by VS Code's traditional file-first UI.

Cursor 3 changes the surface area completely. They’ve built a brand-new interface from scratch that is agent-first. It pulls developers up to a higher level of abstraction—you manage fleets of agents that write the code, but you still retain the full power of an LSP-backed IDE to dive into the files when needed.

🔄 The Magic of Local-to-Cloud Handoff

This is arguably the most mind-blowing feature of the release.

Let's say you're working on a massive refactor. Historically, if you asked an AI to do this, your IDE would be locked up, and if you closed your laptop, the process died.

Cursor 3 introduces seamless handoff between local and cloud environments.

You can kick off a complex, long-running agent task locally, push it to the cloud, and close your laptop. The agent keeps working.
Cloud agents will actually produce demos and screenshots of their work for you to verify when you return.
If you need to tweak the logic, you can pull the session back to your local machine, utilizing Composer 2 (their incredibly fast frontier model) to iterate rapidly.

🛠️ Real-World Workflow: Building with Parallel Agents

To put this in perspective, I’ve been building secure-pr-reviewer, a GitHub App written in TypeScript and Node.js that automates security audits on pull requests.

Previously, scaffolding out the webhooks, writing the AST parsing logic, and generating the test suites meant hopping between different AI chats and hoping they didn't overwrite each other's context.

With Cursor 3's new multi-workspace layout, you can run multiple agents in parallel. I can have one agent looking at my src/ directory building the webhook handler, while a completely separate cloud agent analyzes a test repository to generate mock PR payloads.

Here is an example of the kind of TypeScript code an agent can autonomously write and review in the background while you focus on architecture:

// src/handlers/webhook.ts
import { WebhookEvent } from '@octokit/webhooks-types';
import { analyzeCodeSecurity } from '../utils/scanner';

export async function handlePullRequestEvent(payload: WebhookEvent) {
  if (!('pull_request' in payload)) return;

  const { pull_request: pr, repository: repo } = payload;

  if (payload.action === 'opened' || payload.action === 'synchronize') {
    console.log(`[secure-pr-reviewer] Auditing PR #${pr.number} in ${repo.full_name}`);

    // Agent-generated logic to fetch diff and scan for vulnerabilities
    const diff = await fetchPrDiff(repo.owner.login, repo.name, pr.number);
    const securityReport = await analyzeCodeSecurity(diff);

    if (securityReport.issuesFound > 0) {
      await postReviewComment(repo, pr.number, securityReport.markdown);
    }
  }
}

Once the agent generates this, Cursor 3’s new Diffs view allows you to seamlessly review the changes, stage them, and commit them—taking you from an AI prompt all the way to a merged PR in one unified UI.

🌐 The Built-in Browser & Marketplace

If an agent building your code wasn't enough, Cursor 3 gives the agents eyes.
The IDE now includes an integrated browser. Your AI agent can open local development servers (e.g., localhost:3000), navigate through the UI, and prompt against what it actually sees on the screen.

Furthermore, they’ve introduced the Cursor Marketplace. With a single click, you can extend your agents with MCPs (Model Context Protocols), custom skills, and subagents.

🎯 How to Try It Today

Cursor 3 gives us the foundational pieces—model, product, and runtime—to truly collaborate with AI as a teammate rather than just a smart typewriter.

To experience the new interface:

Upgrade your Cursor desktop app.
Hit Cmd+Shift+P (or Ctrl+Shift+P on Windows).
Search for and select Agents Window.

The era of micromanaging AI is ending. The era of agent swarms is here.

Are you making the jump to Cursor 3, or sticking to your current workflow? Let me know in the comments below! And if you want to see a full, hands-on video breakdown of how I use these new features in my daily workflow, I'll be posting a deep dive over on my YouTube channel, AI Tooling Academy.

🚀 No Managers, No KPIs, $16 Billion Valuation: The Insane Inside Story of Moonshot AI (Kimi)

Siddhesh Surve — Fri, 03 Apr 2026 00:17:43 +0000

If you've spent any time in the tech industry, you know exactly how the typical corporate machine works. We rely on heavy hierarchies, strict KPIs, and layered PR review processes to keep the ship from sinking.

But what if I told you that one of the most valuable AI startups in the world right now operates with absolutely none of that?

Thanks to an incredible undercover report recently highlighted by tech analyst Rui Ma (originally a 100-hour deep dive by Renwu Magazine translated by TechFlow), we finally have a look inside Moonshot AI—the company behind the wildly popular Chinese LLM, Kimi.

This startup is currently valued at over 120 Billion RMB (roughly $16.5 Billion USD).
Their headcount? Just over 300 employees.

Their secret? They deliberately "folded" their entire organization into two dimensions. Here is why their radical approach to engineering culture is sending shockwaves through the tech world, and what we can learn from it. 👇

🤯 The "2D" Organization: Firing the Middlemen

When deep tech companies scale, they usually build pyramids: Junior Devs report to Senior Devs, who report to Engineering Managers, who report to Directors.

Moonshot AI looked at this model and threw it out the window. They operate with:

No Departments
No KPIs
No Job Titles

Instead of a top-down hierarchy, they’ve flattened the company into a literal two-dimensional plane. Every engineer has unprecedented autonomy. In traditional tech companies, you might spend weeks waiting for a feature to get approved by a product manager. At Moonshot, the focus is entirely on shipping and iterating at breakneck speed.

🐝 The "Genius Swarm" Architecture

So, how does a company avoid total chaos without managers? The report describes Moonshot's organizational evolution as a "Genius Swarm."

Think of it like a decentralized compute cluster. Instead of a single master node dictating tasks, the engineers act as autonomous agents that swarm around high-priority problems.

If we were to represent this in code, traditional corporate hierarchy looks like a nested series of blocking functions:

// Traditional Big Tech Hierarchy 🐢
async function shipFeature(idea: string) {
    const pmApproval = await productManager.review(idea);
    if (!pmApproval) return "Blocked";

    const emApproval = await engineeringManager.allocateResources(idea);
    if (!emApproval) return "Backlogged";

    // ... months later
    return execute(idea);
}

Moonshot's "Genius Swarm" operates more like an event-driven pub/sub model. An idea or critical problem is broadcasted, and the nodes (engineers) organically attach themselves to the task based on their expertise and bandwidth:

// Moonshot AI "Genius Swarm" Architecture 🚀
async function swarmExecute(idea: string, swarmNodes: Engineer[]) {
    // Broadcast the problem to the swarm
    const interestedNodes = swarmNodes.filter(node => node.isInterested(idea));

    if (interestedNodes.length > 0) {
        // Build and ship in parallel
        await Promise.all(interestedNodes.map(node => node.build(idea)));
        return "Shipped to production instantly 🔥";
    }

    return "Idea dropped. Not enough organic interest.";
}

By removing the bottleneck of middle management, they ensure that only the most organically compelling and necessary ideas actually get built.

🌊 Surviving the DeepSeek Shockwave

You can't talk about the global AI landscape right now without mentioning DeepSeek. When DeepSeek's incredibly cheap and powerful models (like R1) emerged, it sent a massive shockwave through the entire industry.

For many bloated tech giants, pivoting to match DeepSeek's efficiency would take quarters or even years. But because Moonshot AI functions as a 2D swarm, they were able to rapidly absorb the impact and re-align their collective focus almost overnight. There were no departmental silos to break down or inter-team politics to navigate. They just swarmed the new problem.

🎯 What This Means for the Future of Dev Teams

We are entering a new era of software engineering. As AI tooling handles more of the boilerplate, the need for massive armies of developers is shrinking.

Elite Pods Over Armies: You don't need 5,000 engineers to build a world-class product anymore. A swarm of 300 elite, AI-augmented developers can challenge multi-trillion-dollar giants.
Automated Governance: Instead of relying on human managers to enforce code quality, agile teams are relying on automated guardrails. (This is exactly why I've been so focused on building my secure-pr-reviewer GitHub App—if you want to move at swarm-like speeds, you have to replace human bottlenecks with automated, Node.js and TypeScript-driven security checks).
Hyper-Agility is the Only Moat: The companies that win the AI war won't be the ones with the most funding; they will be the ones that can pivot the fastest.

The traditional corporate ladder is being replaced by the genius swarm. The question is: is your team ready to fold into two dimensions?

What do you think of Moonshot AI's management (or lack thereof) style? Could this work in your current organization, or would it be absolute chaos? Let me know in the comments below!

Forem: Siddhesh Surve

🚀 The "Vibe Coding" Era is Over: What AI Founders Are Building Instead

1. 🛑 Stop Building Wrappers, Start Building Workflows

2. 🏗️ The Move to Agentic Infrastructure

3. 📉 The Rise of the "Micro-Team"

💡 The Takeaway

🚨 The "Context Window" is Dead: Anthropic Just Gave Claude Agents Permanent Memory

🧠 What is Claude Agent Memory?

🛡️ The "Audit Trail" Superpower

💻 Building a "Smart" PR Reviewer in TypeScript

🚀 The Era of Stateful AI

🚀 The "Custom GPT" is Dead: OpenAI Just Dropped Workspace Agents (And They Run in the Background)

🤯 From Chatbots to Background Daemons

💻 The Code: Automating the Automators

🛑 The "Human-in-the-Loop" Safeguards

🚀 Qwen 3.6 Max Preview is Here: Why Your AI Coding Agents Are About to Get a Massive Upgrade

🤯 The Benchmarks: Dominating Agentic Coding

🧠 The Secret Weapon: preserve_thinking

💻 How to Use It in TypeScript

🔮 What’s Next?

🚀 Anthropic Just Dropped "Claude Design" (And It Changes Frontend Development Forever)

🤯 What is Claude Design?

🎨 1. It Auto-Ingests Your Codebase's Design System

⚙️ 2. "Handoff to Claude Code" (The Killer Feature)

🎛️ 3. Dynamic Sliders and Inline Editing

🌐 4. The Web Capture Tool

🤝 The Canva Integration

🎯 The End of the Static Mockup

🔥 Google Just Leaked Its "Desktop Agent" (And It Changes How We Build Software)

🤯 The Shift: From Chat to "Task Execution Workspace"

💻 The Code: How Agents Replace Middleware

🛑 The "Require Human Review" Toggle

🖥️ The Desktop App Invasion

🎯 What's Next?

❄️ OpenAI’s Secret “Codex Superapp” Just Leaked: The End of Standalone ChatGPT?

📝 1. The "Scratchpad": True Parallel Execution

🫀 2. The "Heartbeat" System & Managed Agents

❄️ 3. Project "Glacier" (GPT-5.5?)

🎯 The Takeaway

🚀 OpenAI's Secret "Image V2" Just Leaked on LM Arena: The End of Mangled AI Text?

🕵️‍♂️ The Arena Leak: What is "Image V2"?

🤯 The Holy Grail: AI That Can Actually Spell

🚨 The "Code Red" Counter-Attack

💻 What the API Might Look Like

🔮 The Verdict

🚀 The "Legacy Code" Nightmare is Over: How AI Agents are Automating App Modernization

🛑 The Old Way: Manual Portfolio Audits

🤖 The New Way: Agentic Discovery & Execution

💻 See It In Action: Breaking the Monolith

📘 The Microsoft Playbook Strategy

🎯 The Takeaway

🚀 Qwen 3.6-Plus Just Dropped: The 1M-Context AI Changing the "Vibe Coding" Game

🧠 1 Million Context Window (By Default)

🛡️ The Killer Feature: preserve_thinking

💻 How to Use It (TypeScript Example)

🏆 The Benchmarks: A New Standard

🔮 What’s Next?

🚀 Cursor 3 Just Dropped: Why "Agent Swarms" Are the New Meta for Developers

🤯 Rebuilt from the Ground Up

🔄 The Magic of Local-to-Cloud Handoff

🛠️ Real-World Workflow: Building with Parallel Agents

🌐 The Built-in Browser & Marketplace

🎯 How to Try It Today

🚀 No Managers, No KPIs, $16 Billion Valuation: The Insane Inside Story of Moonshot AI (Kimi)

🤯 The "2D" Organization: Firing the Middlemen

🐝 The "Genius Swarm" Architecture

🌊 Surviving the DeepSeek Shockwave

🎯 What This Means for the Future of Dev Teams

🧠 The Secret Weapon: `preserve_thinking`

🛡️ The Killer Feature: `preserve_thinking`