Replit generated over $125 million in revenue in 2025. Its founders say it’s on track for $1 billion in ARR by end of 2026. That’s the headline. The harder story is what comes next: the AI labs that power Replit’s core product are now building direct competitors to it.

This is the situation Amjad Masad and Haya Odeh find themselves in after nearly 15 years of building together, first as co-workers arguing about whether engineering or design should lead a product, then as partners, co-founders, and spouses.

Where It Started

Masad and Odeh met at Boss Consulting SA, a web consultancy in Amman, Jordan. Masad believed engineering should be the source of truth for software. Odeh argued UX should lead. The friction was productive. When Masad left the firm in 2009, they exchanged numbers at her birthday party and started going out.

Early in the relationship, Masad asked Odeh to help with a side project he’d started in college: a browser-based coding environment called Repl.it. The concept was simple: remove the friction of setting up a programming environment and deploying code, similar to how Google Docs brought word processing to the browser. Odeh designed the logo and worked on the interface. She didn’t fully understand the technology. She helped anyway.

The Long Road to Product-Market Fit

The couple moved to the US in the early 2010s. Masad took a job at Codecademy in New York, then moved to Facebook in Silicon Valley. Odeh built a career in internationalization design and started growing Replit’s user base on the side, taking it from around 5,000 to 50,000 accounts.

In 2016, they went all in. Masad quit Facebook. They officially founded the company. Their original thesis was a classroom product for teaching coding. It gained traction but wasn’t scalable. What they noticed instead was that users were building games and small apps in the browser coding environment without being asked to.

Replit applied to Y Combinator four times. On the fourth try, in winter 2018, it got in. Sam Altman, then YC’s president, had reached out to Masad after Paul Graham discovered Replit on Hacker News. In October 2018, Replit announced a $4.5 million raise led by Andreessen Horowitz. The new mission: a platform where anyone with minimal experience could build, ship, and acquire users for apps, all in one place.

The AI Pivot That Changed Everything

In late 2020, Masad got early access to GPT-3 and immediately understood what it meant for programming. At the time the model could write only a single line of code. He saw the trajectory anyway. In 2021, Replit raised $100 million from A.Capital and Coatue to hire AI engineers and build new features. The first major output was Ghostwriter, an AI autocomplete tool for partially written code.

Ghostwriter doubled Replit’s revenue. It still wasn’t enough. Masad had promised the board $100 million in ARR by end of 2023. The company had overhired. Masad and Odeh laid off 30 of roughly 120 employees. In an internal email Masad posted publicly, he wrote that “now is the time to move fast because the opportunity for Replit has never been clearer.”

The leaner team shipped Replit Agent in September 2024. Unlike Ghostwriter, Agent could build and iterate on apps through a chat interface, then handle deployment and hosting as well. It was built on Anthropic’s Claude 3.5 Sonnet model, which Masad credits with exhibiting significantly better coding capabilities than any model available before it. AI researcher Andrej Karpathy recommended the tool publicly on X. Masad says Replit was the first programming agent to market, and that it indirectly inspired Codex, Claude Code, Bolt, and Lovable.

“The researchers from OpenAI and Anthropic reached out to ask us, ‘How are you able to do this? We didn’t know the models were capable of that.'” — Amjad Masad

Replit’s ARR jumped from $4.1 million to over $250 million in roughly a year. Paid plans start at $18 a month. Karpathy gave the broader category a name in 2025: vibe coding.

What a Replit User Built With It

Eman Khoubian, a former real estate investor, saw Wispr Flow raise a $30 million Series A in June 2025 and decided he could build something similar. He used Replit to develop a web app that converts audio to text, named it Whisper AI, and bought the domain whisperai.com in October 2025. After the domain purchase, signups accelerated. He quit his day job. Whisper AI generated nearly $150,000 in 2025 and, as of mid-2026, was generating six figures in recurring revenue monthly.

Khoubian’s honest assessment of his biggest churn driver: users sign up thinking they’ve found Wispr Flow. Brand confusion is his primary retention problem. He’s building Chrome extensions and desktop apps to compete more directly. The moat problem, at a smaller scale, mirrors Replit’s own.

The Competitive Threat Replit Can’t Ignore

Replit competes with Lovable and Bolt on one front. On another front, it’s competing with the same AI labs it depends on for model access. Claude Code has grown to over $2.5 billion in ARR in a single year. OpenAI’s Codex reports more than five million weekly active users.

The structural disadvantage is real. Research firm SemiAnalysis reports that a $20 Claude Pro or ChatGPT Plus subscription covers $400 to $700 worth of tokens respectively. Replit pays full API token prices. Claude Code and Codex users get far more tokens per dollar than Replit subscribers do. Masad calls this out directly, framing it alongside Apple’s decision to block Replit’s iOS app updates for several months over a dispute about running code that could affect how apps function on the platform. He wrote on X in May that Replit had “worked things out with Apple” and released an update.

“Platforms should not preference themselves,” Masad says. “We should compete on the best product and the best service.”

The Moat Argument

Masad’s case for Replit’s defensibility rests on two things. First, design. Odeh leads a user experience built around how non-technical people actually think: chat for those who talk through ideas, a digital canvas for those who sketch visually. She says the long-term goal is for Replit’s UI to feel more like a mood board than a chatbot. Second, data. Georgian’s Margaret Wu, whose firm led Replit’s $400 million Series D in March, points to Replit’s store of metadata on user intent, including the prompts and questions users send to their agents. That data could train future models to be better at vibe coding specifically.

David Yoffie, a professor at Harvard Business School who studies platform strategy, frames the challenge starkly. Foundation model providers now occupy a position similar to Microsoft’s in the early 2000s: a powerful platform identifying high-revenue opportunities and incorporating them into the core product. Companies that survived Microsoft’s dominance, like Intuit and Adobe, did so by offering products that were hard to replicate. Yoffie says entrepreneurs with a short-term advantage might also want to consider selling to a model provider while the market is still hot.

Masad isn’t selling. He received a medal from Jordan’s King Abdullah II at the country’s 80th independence day celebrations in May, recognition that landed with weight for someone who grew up with, as he put it, “very little means.” The ambition that got him here isn’t going anywhere. “You can’t rest,” he says. “If you miss a beat, someone else will take it.”

The post Replit hit $125M revenue in 2025. Now its suppliers are its rivals. appeared first on BizStack  —  Entrepreneur’s Business Stack.

On Aug. 5, Meta entered the AI coding market with Muse Code, a terminal-based coding agent powered by its new Muse Spark 1.2 model. The launch is notable for two reasons: the pricing is unusually aggressive, and Meta dropped its trademark open source framing entirely.

What Muse Code Is

Muse Code is a standalone terminal agent currently in beta for macOS and Linux. It handles autonomous development workflows, including planning, coding, testing, and result verification in a single pass after receiving a user request.

Two features stand out from the standard AI coding agent playbook. First, persistent asynchronous background agents: rather than spinning up a new helper agent per task, Muse Code keeps specialized sub-agents warm throughout an entire session. According to Meta, this avoids repeated file re-reads that slow down most competing implementations. Sub-agents run inside isolated Git worktrees, so parallel workloads do not contaminate each other’s file state. Branches merge sequentially at integration time, keeping conflict management contained.

Second, append-only local event logs record every model call, tool use, approval, and code edit. If the session crashes, developers can replay the full history and resume from any point. Foreign media outlets cited this as a meaningful step toward proper audit trails and root-cause analysis in agentic coding environments.

Benchmarks and the Controversy Around Them

Meta published benchmark results comparing Muse Spark 1.2 and Muse Code against Grok 4.5, Claude Opus 5, GPT-5.6 Terra, and Gemini 3.6 Flash. On Terminal Bench 2.1, the Muse stack scored 82.9%, ahead of GPT-5.6 Terra and Codex (81.8%) and Grok 4.5 and Grok Build (81.6%), but behind Claude Opus 5 and Claude Code at 86.7%.

The comparison set drew criticism. Developers argued Meta avoided top-tier competitor models in favor of second-tier options, and that a comparison against GPT-5.6 Sol would show lower relative performance. AI tech news site Kingy AI went further, publishing a side-by-side showing Meta’s reported scores as slightly higher than independently verified figures. On Deep SWE 1.1, Muse Spark 1.2 ranked behind both Claude Opus and GPT-5.6 Terra.

️ Pricing: Two Tiers, One of Them Very Cheap

The pricing structure is the most disruptive part of the announcement, according to critics who reviewed it.

• Standard Tier: $1.25 per million input tokens, $4.25 per million output tokens, $0.15 per million cached input tokens. Meta commits not to use prompts or outputs for model training.
• Contributor Tier: $0.10 per million input tokens, $0.20 per million output tokens. In exchange, developers must allow Meta to use their code for future model training.

Meta also confirmed that Zero Data Retention (ZDR) is available to enterprise customers upon request. ZDR means user inputs and outputs are deleted immediately after API call processing, with no temporary server storage at any point. This is typically a hard requirement for regulated industries and organizations with sensitive source code, and its availability on day one signals that Meta is actively targeting enterprise accounts, not just individual developers.

The Context

Meta shipped Muse Code less than a month after releasing Muse Spark 1.1. Observers linked the timing to Moonshot AI’s Kimi K3, which generated significant attention immediately after the Muse Spark 1.1 launch. The absence of any open source framing in the Muse Code announcement is a meaningful shift: Meta’s previous strategy centered on indirect monetization through its open-weight Llama ecosystem. Muse Code is a direct revenue play.

Meta’s Q2 financials add context: revenue of $60.8 billion (up 28% year over year), but operating income down 8% to $18.8 billion, operating margin down from 43% to 31%, and CAPEX of $31.08 billion for the quarter alone, with full-year guidance up to $145 billion. The pricing aggression makes more sense when you see those cost numbers.

The current limitation worth noting: Muse Code is terminal-only at launch. Claude Code supports terminal, IDE, desktop, and web interfaces. OpenAI’s Codex spans CLI tools, IDE extensions, and cloud services. If you need anything outside a terminal today, Muse Code is not yet the answer.

The post Meta launches Muse Code: AI coding agent with aggressive pricing appeared first on BizStack  —  Entrepreneur’s Business Stack.

Google just added a vibe coding course to its AI Professional Certificate on Coursera. The certificate has been the most popular generative AI certificate on the platform since launching in February, with employers like Deloitte, Verizon, Lyft, and Walmart using it to train their teams.

What the new course covers

The vibe coding course teaches learners to plan, test, debug, and deploy apps using plain language descriptions rather than hand-written code. No prior coding experience is required. Target use cases include custom team dashboards, workflow automation, and customer intake tools.

Google points to U.S. search interest in vibe coding as context: it’s up 140% on average versus last year, according to Google Trends data.

Real-world example from the existing curriculum

The source article highlights Leo Garcia, a former Walmart truck driver turned Logistics Load Manager in Bentonville, Arkansas. Using the existing certificate, Garcia built four custom internal apps to optimize operations across several states. One app, called Get My Driver Home, condensed daily reporting meetings into 15-minute huddles and now coordinates driver shifts. Walmart continues to review associate-created apps like his.

Verizon is also offering the certificate to its workforce, with graduates moving from basic email drafting to building tools like virtual quoting assistants inside Gemini Notebook.

The operator takeaway

If you’ve been sitting on an internal tool idea but stalled on the build, this course is worth a look. The gap between “I know what I want” and “I can ship it” is exactly what vibe coding addresses. Google is betting that non-technical operators will close that gap faster with guided instruction than by trial and error alone.

The post Google adds vibe coding course to its AI certificate on Coursera appeared first on BizStack  —  Entrepreneur’s Business Stack.

If you build Laravel apps with Livewire Flux, your AI coding assistant probably does not know which components are free, which require a paid Pro license, or what the current API looks like. livewire-flux-mcp fixes that by connecting your agent directly to live Flux documentation.

What It Does

The package is an MCP server that scrapes and serves structured Flux documentation on demand. It exposes four tools:

• fetch_flux_docs: Pulls the full doc page for a specific component or layout, including the reference section with props and API details. When the component requires a paid Flux Pro license, the response is prepended with a [NOTICE] line flagging it.
• list_flux_components: Lists all available Flux components. Accepts a tier filter (free, pro, or all) and annotates each entry accordingly.
• list_flux_layouts: Lists all available Flux layouts. Returns a friendly notice if you request v1, which has no layouts route.
• list_flux_component_icons: Fetches Heroicons from the GitHub repository for use with the flux:icon component, with filtering by variant and search term.

Why Not Just Laravel Boost?

Laravel Boost already indexes Flux through its search-docs tool, but two gaps remain. First, a broad Flux question can return a several-thousand-token dump from a 17k-document corpus. This server fetches the single component page you asked for. Second, Boost ships a hardcoded component list and does not flag which components need a paid license. This server reads tier data live from fluxui.dev/pricing, with a hardcoded fallback if the pricing page is unreachable.

The two tools are designed to work together: keep Boost for Laravel, Livewire, and Pest; let this server handle Flux.

Version and Pro-Tier Support

The server supports both Flux v2 (default, at fluxui.dev) and v1 (at v1.fluxui.dev). The version argument is accepted on fetch_flux_docs, list_flux_components, and list_flux_layouts. Icon lookups are version-independent since Heroicons are not part of Flux versioning.

Setup

The server runs over stdio via npx, so nothing needs a global install. For Claude Code:

claude mcp add --transport stdio --scope project flux-docs -- npx -y livewire-flux-mcp

For Cursor, add to .cursor/mcp.json:

{
    "mcpServers": {
        "flux-docs": {
            "command": "npx",
            "args": ["-y", "livewire-flux-mcp"]
        }
    }
}

Codex, Gemini CLI, VS Code with Copilot Chat (requires v1.102+), and JetBrains Junie are also supported with agent-specific config snippets in the README. On Windows, wrap the command as cmd /c npx -y livewire-flux-mcp.

Running npx livewire-flux-mcp install in a Laravel Boost project writes an AI skill file, guideline files, and optionally a Claude Code subagent. The skill file deliberately replaces Boost’s bundled fluxui-development skill so Flux lookups route to this server instead.

Caching

Responses are cached in memory with a 24-hour expiration. Cache keys are scoped by component, layout, version, tier, and variant. The icon tool can make up to four GitHub API calls per uncached request, so the cache also serves as GitHub rate-limit protection. Cache resets on server restart.

The package is MIT licensed and available on npm.

The post livewire-flux-mcp gives AI assistants live Flux UI docs appeared first on BizStack  —  Entrepreneur’s Business Stack.

Nutanix just shipped an open-source Model Context Protocol (MCP) server for its Cloud Platform. The practical result: IT teams can point GitHub Copilot, Claude Code, or Cursor at their hybrid multi-cloud infrastructure and issue plain-English commands that translate into real infrastructure actions.

How It Works

The MCP server sits between your AI tool of choice and the Nutanix platform, routing requests through the Prism v4 API Gateway. That routing matters because it means connected AI tools inherit Nutanix’s existing access controls rather than bypassing them. You get AI-driven automation without tearing out the governance layer you already have in place.

What IT Teams Can Do With It

• Analyse system health and surface diagnostics via natural-language queries
• Stage and execute automation workflows with human-in-the-loop controls intact
• Restrict AI agents to authorised APIs using fine-grained role-based access control
• Monitor and meter API usage to prevent runaway automated traffic
• Track which agent initiated which command through comprehensive auditing
• Manage long-running jobs through asynchronous task handling

For Developers

The MCP server can feed AI coding assistants system blueprints and generate infrastructure scripts. Supported output formats include Python, Go, Java, JavaScript, PowerShell, curl, REST, and JSON.

The Operator Takeaway

The headline feature here is not the natural-language interface. It’s that execution stays inside Nutanix’s existing security and governance policies. As Thomas Cornely, EVP of Product Management at Nutanix, put it:

By creating a secure gateway between AI tools and our platform, we are giving customers the confidence to safely use AI to operate and govern their hybrid multi-cloud environments.

For teams already running Nutanix, this is a straightforward on-ramp to agentic automation without a parallel security rebuild. The server is open-source, so you can inspect and fork it before trusting it with production infrastructure.

The post Nutanix ships open-source MCP server for hybrid cloud ops appeared first on BizStack  —  Entrepreneur’s Business Stack.

ChatGPT is now an ad platform. If you run paid acquisition for any product or service, this is worth understanding before your competitors figure it out first.

How ChatGPT Ads work

The core mechanic is conversation targeting. Advertisers can target ChatGPT users whose active conversations are relevant to their products or services. The pitch is intent at the moment it forms, which is structurally similar to how Google Search ads intercept a query in progress.

The difference is context depth. A ChatGPT conversation often contains far more signal than a three-word search query. What OpenAI does with that signal, and how advertisers can access it, is what makes the platform genuinely different from anything already in your media mix.

What early campaigns are showing

According to MarTech contributor John Horn, who has spent his own money and clients’ budgets on the platform, early campaigns are generating data on CPCs, targeting options, measurement, and performance. The specifics are still early-stage, but the pattern is clear: ChatGPT Ads behave differently from Google, Meta, and other established channels.

Horn describes it as a 7-step process to get a first campaign live, covering setup through measurement.

The operator question

For solopreneurs and small teams running lean paid budgets, a new platform always raises the same question: is this worth the setup cost before it scales, or do you wait until the playbook matures?

The case for moving early is the same as it was for Google Search in the early 2000s and for Facebook ads around 2012. New platforms tend to have lower CPCs before demand catches up with inventory. The case for waiting is that measurement on new platforms is notoriously unreliable until the attribution infrastructure matures.

If you already have Google Search campaigns running and a process for tracking conversions, ChatGPT Ads are close enough in concept that the learning curve is manageable. If your attribution is still loose, adding another channel will make it harder to know what’s working.

Where to read the full breakdown

John Horn’s full guide at MarTech walks through the 7-step campaign setup along with the CPC and performance data from real spending on the platform. Worth reading if paid search is part of your acquisition stack.

The post ChatGPT Ads are live: what early campaigns reveal about CPCs and targeting appeared first on BizStack  —  Entrepreneur’s Business Stack.

If you want your brand to show up in ChatGPT answers, user-generated content platforms are where the citations actually come from. According to research from Growth Memo, Reddit, Wikipedia, and LinkedIn together account for 99% of UGC citations in SaaS-related ChatGPT responses.

The Numbers Worth Knowing

UGC sites hold 15-18% of non-vendor cited domains across the AI search journey. That is more than four times the 4% share held by publishers. Community platforms are not a supplementary channel for AI visibility. They are the channel.

There is also a meaningful distinction between personal accounts and brand accounts on these platforms. Named authors and individual representatives tend to outperform brand handles because communities read people as participants rather than advertisers.

The Operator Takeaway

If you are trying to get cited by AI models for your category, the play is to build presence where these citations originate. That means active participation on Reddit in the relevant subreddits, a maintained Wikipedia presence where applicable, and individual thought leadership on LinkedIn rather than just corporate page posts. Pushing content only to your own domain and waiting for AI to find it is the slower path.

The post Reddit, Wikipedia, and LinkedIn drive 99% of UGC citations in ChatGPT appeared first on BizStack  —  Entrepreneur’s Business Stack.

You have a 2,000 row support ticket export and a problem: “can’t log in again ugh” and “authentication failed after password reset” are the same complaint, but your spreadsheet has no signal for that. So you scroll. And scroll. And eventually find the hundred rows that actually need attention.

There’s a better way. This guide walks through a Python script that cleans the CSV with pandas, sends only the unique descriptions to Claude for classification, and flags anything below a confidence threshold for human review. The whole thing runs in about 20 minutes to set up and takes roughly 2 seconds to process 2,004 rows.

You need Python, a Claude API key, and three libraries: anthropic, pandas, and python-dotenv. Install them with:

pip install anthropic pandas python-dotenv

Step 1: Generate the test data

Most tutorials tell you to bring your own data. That’s frustrating because when results look wrong, you don’t know if the script is broken or the data is messy. Generating a known file means you already know what the output should look like.

Save this as a separate Python file and run it once:

"""Build a realistic messy tickets.CSV to test the classifier against."""
import random
import pandas as pd
random.seed(42)
TEMPLATES = [
    # login problems, worded the way people actually word them
    "cant login again ugh",
    "Unable to authenticate after password reset",
    "Login page just spins forever and never loads",
    "Two-factor authentication code never arrives",
    "It says my account doesn't exist but I've had it for years",
    # billing
    "charged $49 twice this month??",
    "I was billed for the annual plan instead of monthly",
    "Invoice #1092 shows the wrong amount",
    "Still being charged after I cancelled",
    # bugs
    "Getting a 500 error when I try to export my report",
    "Dashboard shows stale data even after refreshing",
    "export button does nothing on Safari",
    "app crashes when I upload a photo over 10mb",
    "Search results are missing items that clearly exist",
    # feature requests
    "can you add bulk delete to the dashboard",
    "Would love a keyboard shortcut for creating new tasks",
    "Please add support for exporting to PDF, not just CSV",
    "would be great to have dark mode",
    # the genuinely vague ones
    "Not sure this is the right place, but the site feels slow today",
    "Is there a status page for outages",
    "Just wanted to say the new update looks great",
]

# Unique IDs, so any duplicate in the file is one we put there on purpose.
ids = random.sample(range(3000, 5000), 2000)
rows = [
    {"ticket_id": f"T{i}", "description": random.choice(TEMPLATES)}
    for i in ids
]

# Real exports contain accidental repeats (a webhook fires twice, someone
# re-runs the export). Add four, so the dedup step has something to catch.
rows += random.sample(rows, 4)
df = pd.DataFrame(rows)
df.to_csv("tickets.csv", index=False)
print(f"Wrote {len(df)} rows to tickets.csv")
print(f"  {df.ticket_id.nunique()} unique ticket_ids "
      f"({len(df) - df.ticket_id.nunique()} duplicates)")
print(f"  {df.description.nunique()} unique descriptions")

The output tells you everything you need to verify the rest of the script against: 2,004 rows total, 4 duplicates planted on purpose, and only 21 unique descriptions. If you skip the deduplication step and call Claude once per row, you’re paying to ask the same question roughly 100 times over. The script below avoids that entirely.

Why Claude handles classification but not cleanup

Before writing a single line of AI code, it’s worth being clear about where the model actually earns its keep. A lot of AI automation adds cost without adding value.

Recognizing that “can’t log in again ugh” and “authentication failed after password reset” express the same complaint requires language understanding. That’s Claude’s job. Everything else is pandas.

Step 2: Set up your API key

Create an API key from the Anthropic console and store it in a file called .env in the same folder as your script:

ANTHROPIC_API_KEY=sk-ant-your-key-here

Using python-dotenv to load this at runtime keeps the key out of your source code. A leaked API key means unauthorized access to your Claude account and potentially large unexpected charges.

‍ Step 3: Define Claude’s role before you write the prompt

Claude’s job here is narrow on purpose: sort each ticket into exactly one of five categories and attach a confidence score. That’s it. It doesn’t resolve tickets, draft responses, or make judgment calls on priority.

The five categories are Billing, Login Issue, Bug Report, Feature Request, and Other. Anything Claude isn’t confident about gets flagged for human review rather than silently mislabeled.

Keeping the task single-purpose is what makes the output trustworthy. The more you ask a model to do in one call, the more ways it has to go wrong.

Step 4: Clean the CSV before touching the API

Strip whitespace and drop duplicate ticket IDs using pandas before a single API request goes out:

import pandas as pd
df = pd.read_csv("tickets.csv")
df["description"] = df["description"].str.strip()
before = len(df)
df = df.drop_duplicates(subset="ticket_id").reset_index(drop=True)
print(f"Dropped {before - len(df)} duplicate(s), {len(df)} tickets left.")

This drops the 4 planted duplicates before they reach Claude. If your export had 400 duplicates instead of 4, skipping this step would cost you 400 unnecessary API calls on data you already processed.

Step 5: Send tickets in batches, not one at a time

Two decisions keep the API bill small. First, group tickets into batches of 20 per request instead of one per request. Every API call has overhead; batching absorbs it. Second, cache results so identical descriptions are never sent twice.

The categorize_tickets function sends a numbered list to claude-haiku-4-5-20251001 and parses the response line by line:

import os
from anthropic import Anthropic
from dotenv import load_dotenv
load_dotenv()
client = Anthropic(api_key=os.getenv("ANTHROPIC_API_KEY"))
CATEGORIES = ["Billing", "Login Issue", "Bug Report", "Feature Request", "Other"]
MODEL = "claude-haiku-4-5-20251001"
SYSTEM_PROMPT = (
    "You are a classifier for support tickets. You will receive a numbered "
    "list of tickets. Classify each ticket into exactly one of these "
    f"categories: {', '.join(CATEGORIES)}. "
    "Respond with one line per ticket in the form "
    "'<number>. <category>, <confidence>', where confidence is a score from "
    "0 to 1. Match the input numbering exactly. No other text."
)
def categorize_tickets(client, descriptions):
    ticket_list = "n".join(
        f'{i}. "{d}"' for i, d in enumerate(descriptions, start=1)
    )
    response = client.messages.create(
        model=MODEL,
        max_tokens=25 * len(descriptions),
        temperature=0,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": f"Tickets:n{ticket_list}"}],
    )
    lines = [l.strip() for l in response.content[0].text.strip().splitlines() if l.strip()]
    if len(lines) != len(descriptions):
        raise ValueError(f"Asked about {len(descriptions)}, got {len(lines)} answers back")
    results = []
    for i, line in enumerate(lines, start=1):
        number, dot, rest = line.partition(".")
        if not dot or number.strip() != str(i):
            raise ValueError(f"Line {i} is misnumbered: {line!r}")
        category, comma, confidence = rest.partition(",")
        if not comma:
            raise ValueError(f"Line {i} has no confidence score: {line!r}")
        category = category.strip()
        confidence = float(confidence.strip())
        if category not in CATEGORIES:
            raise ValueError(f"Made-up category: {category!r}")
        if not 0.0 <= confidence <= 1.0:
            raise ValueError(f"Confidence out of range: {confidence!r}")
        results.append((category, confidence))
    return results

Most of that function is response validation, not API logic. That’s deliberate. Claude is good at classification but can still drop a line or invent a category label. Without strict parsing, a mislabeled row looks identical to a correct one in your output CSV.

Haiku is used instead of Sonnet or Opus because sorting a sentence into five buckets doesn’t require a more expensive model. Model choice is the single biggest lever on your API bill.

Step 6: Cache answers across the full run

The classify_dataframe function identifies which descriptions haven’t been seen yet, groups them into batches, and uses a shared cache dictionary so duplicate descriptions are never sent to Claude twice:

from concurrent.futures import ThreadPoolExecutor, as_completed
def classify_group(client, descriptions):
    try:
        return categorize_tickets(client, descriptions), 0
    except Exception as exc:
        print(f"  Group of {len(descriptions)} failed ({exc}), retrying one by one")
    results, failed = [], 0
    for d in descriptions:
        try:
            results.append(categorize_tickets(client, [d])[0])
        except Exception:
            results.append(("Needs Review", 0.0))
            failed += 1
    return results, failed
def classify_dataframe(df, client, cache, max_workers=5, group_size=20):
    descriptions = df["description"].tolist()
    unseen = [d for d in dict.fromkeys(descriptions) if d not in cache]
    groups = [unseen[i:i + group_size] for i in range(0, len(unseen), group_size)]
    print(f"  {len(df)} rows, but only {len(unseen)} new sentences "
          f"= {len(groups)} request(s)")
    failed = 0
    with ThreadPoolExecutor(max_workers=max_workers) as pool:
        futures = {pool.submit(classify_group, client, g): g for g in groups}
        for future in as_completed(futures):
            group = futures[future]
            results, group_failed = future.result()
            cache.update(zip(group, results))
            failed += group_failed
    df[["predicted_category", "confidence"]] = pd.DataFrame(
        [cache[d] for d in descriptions], index=df.index
    )
    return df, failed

Against the 2,000 ticket test file, this produces 2 requests instead of 2,000. If one batch fails, classify_group retries each ticket in that batch individually rather than marking the entire group as failed.

Step 7: Flag low-confidence results for human review

CONFIDENCE_THRESHOLD = 0.9
df["category"] = df["predicted_category"]
low = df["confidence"] < CONFIDENCE_THRESHOLD
df.loc[low, "category"] = "Needs Review"
print(f"{low.sum()} of {len(df)} flagged for a human.")
df.to_csv("tickets_categorized.csv", index=False)

The output file keeps two columns: predicted_category holds Claude’s original guess, and category holds the final label. When confidence falls below 0.9, only category changes to “Needs Review”. The original guess stays intact so you can audit it later.

The threshold is set at 0.9 on purpose. Sending a few extra rows to a human costs nothing. A confidently wrong label in your final report costs considerably more. Run it, see what gets flagged, then adjust the threshold to match your data.

Step 8: Make it production-ready

The script above works, but the filename is hard-coded and loading a large CSV all at once will exhaust memory. Four changes close the gap between demo and real tool.

Accept CLI arguments instead of hard-coding filenames

Use Python’s argparse to pass the input file, output file, worker count, and group size on the command line. The same script then runs on any file without editing source code. Arguments: --input, --output, --workers, --group-size.

Catch duplicates across chunks, not just within them

Do a fast first pass reading only the ticket_id column before loading any descriptions. This identifies every ID that repeats anywhere in the file so deduplication works even when duplicate rows land in different chunks:

id_col = pd.read_csv(args.input, usecols=["ticket_id"])
dupe_ids = set(id_col[id_col.duplicated(keep="first")]["ticket_id"])
kept = set()
# inside the chunk loop:
before = len(chunk)
is_dupe = chunk["ticket_id"].isin(dupe_ids)
already_kept = chunk["ticket_id"].isin(kept)
chunk = chunk[~(is_dupe & already_kept)]
kept.update(chunk.loc[chunk["ticket_id"].isin(dupe_ids), "ticket_id"])
dropped = before - len(chunk)

Process in chunks of 500 rows

Use pd.read_csv(chunksize=500) and write each chunk’s results to the output file immediately. If the script crashes at row 40,000, the first 39,999 rows are already saved.

Let the SDK handle rate-limit retries

Pass max_retries when initializing the Anthropic client. Transient rate-limit pauses are retried automatically rather than being marked as failures and labeled “Needs Review.”

The complete script

Save this as task.py with your .env and tickets.csv in the same folder, then run python task.py --input tickets.csv:

import argparse, os, time
from collections import Counter
from concurrent.futures import ThreadPoolExecutor, as_completed
import pandas as pd
from anthropic import Anthropic
from dotenv import load_dotenv
load_dotenv()
API_KEY = os.getenv("ANTHROPIC_API_KEY")
if not API_KEY:
    raise RuntimeError("ANTHROPIC_API_KEY is not set. Check your .env file.")
CATEGORIES = ["Billing", "Login Issue", "Bug Report", "Feature Request", "Other"]
MODEL = "claude-haiku-4-5-20251001"
CONFIDENCE_THRESHOLD = 0.9
REQUIRED_COLUMNS = {"ticket_id", "description"}
SYSTEM_PROMPT = (
    "You are a classifier for support tickets. You will receive a numbered "
    "list of tickets. Classify each ticket into exactly one of these "
    f"categories: {', '.join(CATEGORIES)}. "
    "Respond with one line per ticket in the form "
    "'<number>. <category>, <confidence>', where confidence is a score from "
    "0 to 1. Match the input numbering exactly. No other text."
)
def categorize_tickets(client, descriptions):
    ticket_list = "n".join(f'{i}. "{d}"' for i, d in enumerate(descriptions, start=1))
    response = client.messages.create(
        model=MODEL,
        max_tokens=25 * len(descriptions),
        temperature=0,
        system=SYSTEM_PROMPT,
        messages=[{"role": "user", "content": f"Tickets:n{ticket_list}"}],
    )
    lines = [l.strip() for l in response.content[0].text.strip().splitlines() if l.strip()]
    if len(lines) != len(descriptions):
        raise ValueError(f"Asked about {len(descriptions)}, got {len(lines)} back")
    results = []
    for i, line in enumerate(lines, start=1):
        number, dot, rest = line.partition(".")
        if not dot or number.strip() != str(i):
            raise ValueError(f"Line {i} is misnumbered: {line!r}")
        category, comma, confidence = rest.partition(",")
        if not comma:
            raise ValueError(f"Line {i} has no confidence score: {line!r}")
        category = category.strip()
        confidence = float(confidence.strip())
        if category not in CATEGORIES:
            raise ValueError(f"Made-up category: {category!r}")
        if not 0.0 <= confidence <= 1.0:
            raise ValueError(f"Confidence out of range: {confidence!r}")
        results.append((category, confidence))
    return results
def classify_group(client, descriptions):
    try:
        return categorize_tickets(client, descriptions), 0
    except Exception as exc:
        print(f"  Group of {len(descriptions)} failed ({exc}), retrying one by one")
    results, failed = [], 0
    for d in descriptions:
        try:
            results.append(categorize_tickets(client, [d])[0])
        except Exception as exc:
            print(f"  Ticket {d[:40]!r} failed: {exc}")
            results.append(("Needs Review", 0.0))
            failed += 1
    return results, failed
def classify_dataframe(df, client, cache, max_workers=5, group_size=20):
    descriptions = df["description"].tolist()
    unseen = [d for d in dict.fromkeys(descriptions) if d not in cache]
    groups = [unseen[i:i + group_size] for i in range(0, len(unseen), group_size)]
    print(f"  {len(df)} rows, {len(unseen)} new sentence(s) = {len(groups)} request(s)")
    failed = 0
    with ThreadPoolExecutor(max_workers=max_workers) as pool:
        futures = {pool.submit(classify_group, client, g): g for g in groups}
        for future in as_completed(futures):
            group = futures[future]
            results, group_failed = future.result()
            cache.update(zip(group, results))
            failed += group_failed
    df[["predicted_category", "confidence"]] = pd.DataFrame(
        [cache[d] for d in descriptions], index=df.index
    )
    return df, failed
def find_duplicate_ids(path):
    id_col = pd.read_csv(path, usecols=["ticket_id"])
    return set(id_col[id_col.duplicated(keep="first")]["ticket_id"])
def load_chunks(path, chunk_size):
    for i, chunk in enumerate(pd.read_csv(path, chunksize=chunk_size)):
        if i == 0:
            missing = REQUIRED_COLUMNS - set(chunk.columns)
            if missing:
                raise ValueError(f"CSV is missing column(s): {', '.join(sorted(missing))}")
        yield chunk.reset_index(drop=True)
def parse_args():
    p = argparse.ArgumentParser(description="Sort support tickets with Claude.")
    p.add_argument("--input", default="tickets.csv")
    p.add_argument("--output", default="tickets_categorized.csv")
    p.add_argument("--workers", type=int, default=5)
    p.add_argument("--group-size", type=int, default=20)
    p.add_argument("--chunk-size", type=int, default=500)
    p.add_argument("--max-retries", type=int, default=2)
    return p.parse_args()
def main():
    args = parse_args()
    client = Anthropic(api_key=API_KEY, max_retries=args.max_retries)
    dupe_ids = find_duplicate_ids(args.input)
    kept_dupe_ids = set()
    start = time.time()
    cache = {}
    counts = Counter()
    total = dropped = flagged = failed = 0
    first = True
    for n, chunk in enumerate(load_chunks(args.input, args.chunk_size), start=1):
        print(f"--- Chunk {n} ({len(chunk)} rows) ---")
        chunk["description"] = chunk["description"].str.strip()
        before = len(chunk)
        chunk = chunk.drop_duplicates(subset="ticket_id").reset_index(drop=True)
        is_dupe = chunk["ticket_id"].isin(dupe_ids)
        already_kept = chunk["ticket_id"].isin(kept_dupe_ids)
        chunk = chunk[~(is_dupe & already_kept)].reset_index(drop=True)
        kept_dupe_ids.update(chunk.loc[chunk["ticket_id"].isin(dupe_ids), "ticket_id"])
        dropped += before - len(chunk)
        if len(chunk) == 0:
            print(f"  0 rows left after dedup, skipping this chunk")
            continue
        chunk, chunk_failed = classify_dataframe(
            chunk, client, cache,
            max_workers=args.workers, group_size=args.group_size,
        )
        chunk["category"] = chunk["predicted_category"]
        low = chunk["confidence"] < CONFIDENCE_THRESHOLD
        chunk.loc[low, "category"] = "Needs Review"
        chunk.to_csv(args.output, mode="w" if first else "a",
                     header=first, index=False)
        first = False
        counts.update(chunk["category"])
        total += len(chunk)
        flagged += int(low.sum())
        failed += chunk_failed
    print(f"nDone in {time.time() - start:.1f}s.")
    print(f"{total} tickets, {dropped} duplicate(s) dropped, "
          f"{flagged} flagged for review ({failed} of those were errors).")
    print(f"Only {len(cache)} unique sentences were ever sent to Claude.")
    for category, count in counts.most_common():
        print(f"  {category}: {count}")
if __name__ == "__main__":
    main()

The final run processes 2,004 rows, drops 4 duplicates, classifies via 21 unique sentences sent to Claude, and completes in about 2 seconds. The results file includes a “Needs Review” filter for anything below the 0.9 confidence threshold. Tickets like “Not sure this is the right place, but the site feels slow today” land there by design: too vague for confident classification, exactly what a human should read.

Common pitfalls

• One API call per row. Without batching and caching, 2,004 rows means 2,004 requests to classify 21 sentences. The grouping and caching in Steps 5 and 6 collapse this to 2 requests.
• Skipping response validation. Claude can drop a line or return a label that isn’t in your category list. Without the parsing checks in categorize_tickets, a wrong label looks identical to a correct one in your output CSV.
• Dropping the confidence threshold. Without it, tickets Claude doubted are indistinguishable from tickets Claude was certain about. The only signal pointing you to rows worth checking disappears.
• Using a larger model than the task needs. Haiku classifies these sentences accurately. Opus does too, but at considerably higher cost for the same result.
• Raising worker count past your rate limit. More workers don’t mean more speed if you exceed your API tier’s limit. You get throttling, not throughput.

When one script isn’t enough

This script handles classification from a file. When you outgrow it, here’s what to reach for next:

• Claude Agent SDK: when you want the agent to take actions (read files, run tools, write changes) instead of returning answers for you to handle.
• Model Context Protocol (MCP): when tickets live in a helpdesk or database instead of a CSV. MCP lets Claude query the source directly without a manual export step.
• Message Batches API: for large volumes where turnaround time isn’t urgent. The developer notes it costs roughly half as much as synchronous requests, in exchange for delayed results. This is a separate feature from the request-grouping done in Step 5, though both are sometimes called batching.
• LangChain: when a single prompt isn’t enough and you need to chain multiple steps or pull in additional context before classification.
• n8n: when the person maintaining the workflow doesn’t know Python. It has a visual drag-and-drop interface with a built-in Claude node.

The post Classify 2,000 support tickets with Claude using 21 API calls appeared first on BizStack  —  Entrepreneur’s Business Stack.

The debate about AI’s role in marketing tends to collapse into two positions. Either the machines will eventually run the whole function, or humans stay firmly in charge and AI is just a faster assistant. At the 17th Digital Leadership Summit in Bengaluru, a third framing emerged: the machines run the middle, and a human still owns the call.

The summit was hosted by Social Beat with Google India and Cheil at the Taj MG Road on 31 July 2026. This was the third of three themes covered across the event.

The Middle vs. The Call

The distinction matters for any operator building a marketing function today. AI handles the volume work: drafting, testing, targeting, analyzing. But the consequential decisions, the ones that carry brand, legal, or budget risk, still require a human signature.

That framing is less about philosophical preference and more about accountability. When something goes wrong with an automated campaign, someone has to own it. The organizational reality is that AI cannot be held responsible. A person can.

GEO: The Visibility Problem Most Brands Haven’t Solved

One of the sharpest points raised at the summit came from Social Beat’s own tool, GEO Pulse, built specifically to measure AI search visibility. The honest finding: most brands cannot yet confirm whether they appear in an AI-generated answer for their own category.

That gap is the core problem GEO optimization addresses. Whether you call it GEO optimization, AI search optimization, or AI Overview SEO, the underlying work is the same: structure your content so that AI engines, including ChatGPT, Perplexity, and Gemini, can find it, quote it, and credit it when answering a buying question in your space.

This is a different discipline from traditional SEO. Search engine optimization targeted crawlers and ranking algorithms. GEO targets the summarization and citation layer that sits on top of search. If your content does not get pulled into an AI answer, you may not get the traffic at all, because many users never click through from an AI Overview.

The Operator Takeaway

Three things to pull from this session:

• Audit your AI search presence first. Before optimizing, find out whether you currently appear when someone asks an AI engine a buying question in your category. Most brands have not done this check.
• Treat GEO as a distinct workstream. It is not a feature of your existing SEO process. It requires different content structure, different attribution thinking, and different measurement.
• Keep a human on final approval. The accountability gap is real. Automated systems can produce output at scale, but the decision to publish, spend, or respond still needs an owner.

The summit featured organizations including NoBroker and Orange Health Labs alongside platform perspectives from Google and Meta. The session framing comes from Social Beat, the event’s host organization.

The post AI in marketing: who owns the call when machines run the middle? appeared first on BizStack  —  Entrepreneur’s Business Stack.

If your AI prompts still contain “double-check your work,” “think step by step,” or a wall of ALWAYS/NEVER rules, you’re writing for a model that no longer exists. Current reasoning models, including GPT-5.6, Opus 5, and Kimi-3, already run an internal verification pass and pace their own depth. Those extra lines don’t add safety. They add friction and burn tokens on work the model was going to do anyway.

What the data says

OpenAI found that trimming internal agent prompts, cutting repeated instructions, unnecessary examples, and irrelevant tool descriptions, raised evaluation scores by 10 to 15%. The same trimming dropped token consumption between 41 and 66%, and cut cost by up to 67%. That’s not a marginal gain from cleaner writing. That’s a structural improvement from removing instructions the model was actively working around.

The four settings a model still can’t infer

The argument isn’t for shorter prompts as an end in themselves. A short but vague prompt still fails. The goal is a prompt where every remaining line does something the model’s defaults don’t already cover. According to the author, four settings qualify:

• Effort: Replace “think hard” or “think deeply” with the model’s official effort selector (low, medium, high, or max). Start low and raise it only when the task genuinely needs more depth. Note that the exact parameter name and accepted values differ across providers, so confirm before relying on it.
• Scope: State what the model should and shouldn’t touch. Without a scope boundary, a one-file fix can turn into a refactor of the whole module.
• Length: Specify a paragraph, a table, or three bullets. “Be concise” without specifics leaves the model guessing what to cut.
• Autonomy: The author recommends a three-level policy: act without asking on reversible low-risk steps, confirm before anything destructive or hard to undo, and for pure analysis or planning, inspect and report without touching code. Anthropic’s guidance on Opus 5 states directly that explicit verification instructions cause over-verification in modern models and should be removed.

What to delete from existing prompts

• Forced verification lines: “double-check your work,” “review before answering”
• Vague depth requests: “think deeply,” “think hard”
• ALWAYS/NEVER absolutes written for judgment calls rather than genuine invariants
• Duplicate rules: each constraint should appear exactly once
• Bare “be concise” with no specifics on what to keep or cut

What the replacement structure looks like

The author proposes a 2026 prompt template with six fields: Role, Objective, Success criteria, Constraints, Output format, and Stopping rules. Business rules, security limits, and data boundaries stay in regardless of how short the rest gets. Those aren’t scaffolding, they’re non-negotiable constraints that belong in every version of the prompt.

The article also includes a meta-prompt approach: feed your old prompt into a prompt that applies these rules and returns a trimmed version, so you don’t have to audit legacy prompts by hand.

One caveat: this approach targets reasoning models with explicit effort parameters and strong default self-verification. Older or smaller models without those defaults may still need the scaffolding this tip removes.

The post Stop over-prompting reasoning models: 4 settings that matter appeared first on BizStack  —  Entrepreneur’s Business Stack.