DEV Community: Mashraf Aiman

How to make link to SaaS Launch Video system

Mashraf Aiman — Mon, 02 Nov 2026 02:16:23 +0000

A screenshot can show what you built. A screen recording can show how it works. But making a short, polished launch video usually means opening another set of tools—and spending time editing instead of sharing.

/brag is an open-source agent skill designed to help with that last step. Point an agent at a project, and it can inspect the code, plan a short video, and prepare the output for sharing.

Watch the examples and see the project

What is /brag?

/brag reads a project’s source code to understand what the product does, what it looks like, and which details are worth showing. It then creates a video plan and hands a focused composition brief to Hyperframes, which handles the composition and rendering workflow.

The output includes the rendered video, a poster image, and a share caption—along with the plan and composition files.

From project code to video

The classic /brag workflow has four steps:

Inspect the project. Read relevant files to identify the product, audience, visual identity, and user flow.
Plan the story. Choose a creative angle, write a hook, and lay out the video scene by scene.
Build the composition. Give Hyperframes the brief, including the visual direction and storyboard.
Validate and deliver. Check the composition, render the video, select a poster frame, and write share copy.

The story usually follows a simple shape:

Hook → product reveal → highlights → close

That shape is a guide, not a rigid template. The video is meant to show the actual product—not just string together generic marketing claims.

A typical output folder looks like this:

brag-output/
  brag-plan.md
  composition-brief.md
  brag.mp4
  brag.jpg
  share-copy.txt
  composition/

The plan and brief document the creative direction, while the video, poster, and caption are the pieces ready to share.

What makes a good brag video?

The project’s instructions set a few useful creative constraints:

Keep it short: usually 15–25 seconds.
Make the hook count: the opening seconds should give people a reason to keep watching.
Show the product: include real UI, copy, or other recognizable project details.
Keep text readable: use motion and cuts to create pace, not text that disappears before it can be read.
Stay specific: avoid claims and phrases that could describe any product.
Make it shareable: choose a strong poster frame and write a caption that works outside the video.

The workflow also includes a validation step before rendering. In the classic path, Hyperframes’ check helps catch issues such as text overflow and contrast problems.

Two workflows: /brag and /brag-slim

The repository includes two approaches:

/brag uses Hyperframes to build and render the composition.
/brag-slim is a lean, single-file workflow. The agent builds the video with tools already available on the machine, without Hyperframes or bundled assets.

On Claude Opus 5.5, /brag switches to /brag-slim by default. Use /brag --full to request the classic Hyperframes workflow instead.

Try it

Install the skill with the skills CLI:


bash
npx skills add https://github.com/latent-spaces/brag --skill brag


MASHRAF AIMAN
CTO and Co-founder Ennovat Studio

[Boost]

Mashraf Aiman — Thu, 22 Oct 2026 12:20:36 +0000

Covers new APIs, Effect edge cases, and OSS usage

nyaomaru

Oct 21

is-kit Reached 100 Stars ⭐🎉 Here’s What Changed Since 50

#typescript #opensource #webdev #frontend

128

7 min read

How to claim your banner on 👑SaaSThrone in 3 Simple Steps

Mashraf Aiman — Wed, 21 Oct 2026 10:59:57 +0000

Want to put your SaaS product on the map? Claim your banner on SaaSThrone and secure your place in the realm.

It's simple. Just follow these 3 steps:

🔗 1. Paste Your Product URL

Enter the URL of your SaaS product to get started.

🛡️ 2. Choose Your Realm

Pick the realm where you want your banner to appear and claim your spot.

👑 3. Pay & Take Your Rank

Complete the payment, and once it's confirmed, your banner goes live!

That's it. Three steps to claim your place in the kingdom. ⚔️

Ready to claim your banner?

👉 Visit saasthrone.lol and claim your spot today!

Your product. Your banner. Your throne. 👑

I Built a Game of Thrones-Themed Marketplace for Bidding on SaaS Products

Mashraf Aiman — Wed, 21 Oct 2026 10:04:22 +0000

Most SaaS launch platforms have the same problem: you post, get a spike of upvotes for 24 hours, and then silence.

I wanted something with more energy. So I built SaasThrone, a Game of Thrones-themed platform where SaaS products are listed, bid on, and fought over like a seat on the Iron Throne.

What is SaasThrone?

SaasThrone is a place to list your SaaS and let people bid on it. Founders get visibility and real buyer interest. Bidders and early adopters get first access to products they'd otherwise never find.

It's built around two ideas:

The Great Council: where listings are presented and the community weighs in.
Daily Courts: a fresh daily arena where products compete for attention, so every day is a new chance to be seen.

Why the GoT theme?

Because dry marketplaces are forgettable. A theme gives the platform a personality, and personality is what makes people share it. Listing your product shouldn't feel like filling out a tax form.

Who is it for?

SaaS founders who want more eyes on their product (and maybe a buyer)
Indie hackers with side projects sitting idle
Bidders and early adopters who like discovering tools before everyone else does

Getting in is cheap

The minimum to join is $1. It keeps the barrier low and filters out the noise.

Try it

If you've got a SaaS (live, side project, or half-abandoned), list it and see who bids:

👉 saasthrone.lol

I'm building this in public, so I'd love to hear what you think. What would make you list your product on a platform like this? Drop it in the comments.

Built Mock Visa Interview AI - 15 Countries expanded, 200+ Universities, in 4 months

Mashraf Aiman — Fri, 29 May 2026 11:30:20 +0000

The technical story behind VisaCracked — a multi-agent voice AI system that simulates real student visa interviews. Built on Vapi, trained on 78 pages of real transcripts, and growing faster than anything we've shipped before.

I've shipped somewhere between 30–40 SaaS products. Most flatlined. Some made a little noise and went quiet.

VisaCracked is different.

Four months in: 15+ countries, 50+ paid transactions, users at 200 universities — including MIT, Harvard, Purdue, Rochester, Gettysburg College, Knox College, Rowan, Franklin & Marshall, Denison, Allegheny, Colby, Oberlin, Bucknell, and dozens more.

And then there's Brad.

Brad is the Director at Gettysburg College. He tried VisaCracked before his students' F-1 visa interviews. Then he emailed every single admitted student in his cohort about it — unprompted. That's the kind of signal you can't manufacture.

This post is the technical breakdown of how we built it.

The Problem

Every year, thousands of students get accepted into US universities — then get rejected at the F-1 visa interview.

The interview is 2–5 minutes. One consular officer. High stakes. And the preparation ecosystem is: YouTube videos, Reddit posts, and advice from a senior who went through it three years ago.

There's no structured practice. No feedback loop. No way to know if you're giving off the wrong signals until it's too late.

We built VisaCracked to fix that.

The Architecture: Two AIs, One Interview

The core is a multi-agent system with two distinct AI roles:

1. The Interview AI

Conducts the live voice interview. It:

Opens every session with "Good morning [name]. Passport please." — because that's exactly how it starts in real life
Asks follow-up questions based on your answers
Runs across 3 difficulty levels (lenient → standard → adversarial), each calibrated to a different consular officer style
Keeps every question under 12 words — because real officers don't give speeches

2. The Judgment AI

Evaluates the full transcript after the session ends. It:

Scores across weighted categories (ties to home country, financial credibility, study intent, consistency, etc.)
Returns structured JSON with nullable fields for untested areas
Generates a personalized feedback report with specific weak points

Both AIs were trained on 78 pages of real F-1 interview transcripts — not hypotheticals, not YouTube compilations. Actual interview data.

The technology we used

Web Application techs, Deepseek, Antropic, Mistral, Gemini, Deepgram, Vapi etc.

The Voice Layer: Vapi

We chose Vapi for the real-time voice interface. It handles:

Speech-to-text during the interview
Text-to-speech for the AI's questions
Low-latency turn-taking that makes the conversation feel natural

A few Vapi-specific things we had to solve:

TTS stage directions — early prompts accidentally fed stage directions into speech. Fixed with strict output formatting rules.
Digit formatting — numbers like "221g" (a common visa refusal code) were being misread. We built handling to preserve these strings.
Variable injection — Vapi uses {{double_curly_braces}} syntax for variable injection. We have two intentional "typos" in variable names (total_expendature, previous_rejectons) that had to be preserved exactly across all prompts to maintain parity with the connected data layer.

What We Got Obsessive About

A few non-obvious design decisions that made a real difference:

Immigrant intent detection — most visa prep tools focus on "do you have home ties?" We built the AI to detect positive signals of immigrant intent too: language suggesting you might not return, vague post-graduation plans, over-attachment to the destination country. Consular officers are trained to catch this. So is ours.

Answer drift detection — the AI tracks consistency across the full interview. If your funding story at minute 1 doesn't match what you say at minute 4, it flags it. This is one of the most common real-world rejection triggers.

PhD fast-lane logic — fully funded PhD applicants get a compressed interview with fewer financial questions and more research-intent questions. Different visa profile, different question logic.

Curveball questions — drawn directly from edge cases in the real transcript data. Things like being asked about a sibling who previously overstayed a visa, or explaining a gap year that doesn't appear on your I-20.

75-point pass threshold — consistent across all three difficulty levels. The Judgment AI returns a score and a binary pass/fail. We calibrated this against the real transcript data to match approximate real-world approval patterns.

The User Feedback That Said It All

"I used GPT and Claude, but VisaCracked has something extra personalized and has the vibe of a real interview."

This is the vertical AI thesis playing out in practice. General-purpose models are brilliant. But they don't know that certain funding structures get more scrutiny. They don't have 78 pages of real transcripts shaping the question logic. They haven't been tuned for the exact psychological texture of a 3-minute high-stakes conversation.

Depth of domain knowledge creates experiences that feel fundamentally different — not just "an AI doing a thing," but a product that clearly understands the thing.

University Reach (4 Months In)

Users have come from across the board — from flagship state schools to elite liberal arts colleges:

MIT · Harvard · Stanford · Purdue · University of Rochester · Michigan State · Florida State · UMass Amherst · University at Buffalo · University of Alabama · Georgia State · Texas State · University of Texas at Arlington · UT Dallas · UTEP · UT Southwestern · Oklahoma State · Wichita State · Bowling Green State · Kennesaw State · Southeast Missouri State · University of South Dakota · University of Kentucky · University of Charleston · NJIT · RIT · Rose-Hulman · Rowan · Willamette · Oberlin · Bucknell · Gettysburg · Franklin & Marshall · Dickinson · Colby · Knox · Denison · Allegheny · DePauw · Wabash · Centre College · Whitman · Beloit · Luther · Lawrence · Lafayette · Illinois College · Connecticut College · College of Wooster · and more.

The Team

Ahsan Foez Nahiyan (CMO) and Istiaque Zaman (COO) — 15 countries in 4 months doesn't happen without sharp distribution and relentless execution.

Mashraf Aiman (CTO) — built the core architecture, most hours in the system, made the calls that turned an idea into something that holds up under real interview pressure.

What's Next

We're expanding beyond F-1. The student visa prep problem exists for UK Tier 4, Canada Study Permit, Schengen student visas, and more. The multi-agent architecture generalizes — what changes is the domain knowledge layer.

We're also building session comparison (track improvement across multiple runs) and benchmarking within the same visa category and origin country.

If you're a student prepping for a visa interview — try VisaCracked.

If you're building vertical AI products and want to compare notes on multi-agent interview design, judgment AI calibration, or voice pipeline architecture — drop a comment. Happy to go deeper on any of this.

VisaCracked is live at visacracked.com. USA F-1, AUS student visa simulation live now. More student visa types coming soon.

[Boost]

Mashraf Aiman — Sun, 12 Apr 2026 08:16:58 +0000

Metadata and branch hygiene checklist

Giorgi Kobaidze

Apr 11

The Final 1% of Every GitHub Project: Sealing It Properly

#github #opensource #development #repository

112

12 min read

Amazing

Mashraf Aiman — Sun, 12 Apr 2026 08:14:20 +0000

The Devs man

Apr 12

Gemma 4: Byte for byte, the most capable open models

#gemma #ai #open #models

15 min read

I Stopped Vibe Coding and Started Using Prompt Contracts, Here's What the Data

Mashraf Aiman — Fri, 27 Mar 2026 16:56:14 +0000

You asked Claude Code to build a Supabase auth flow with row-level security.
You got a flawless, production-grade Firebase auth system.
Technically impressive. Fundamentally wrong. 2,400 lines of perfectly clean code, deleted at 2 AM.
That's the story that kicked off Philippe Eveilleau's viral Medium post — and it hit because every developer using Claude Code has a version of that story. Maybe yours was a payment integration that worked in staging and silently failed in production. Maybe it was an auth system that inverted a truthy check and gave deactivated accounts admin access for two weeks. Maybe it was just a function that passed your test case and rejected every international email address your users actually had.
The pattern has a name now. The industry has data on it. And there's a method that actually fixes it — one that Eveilleau formalized as Prompt Contracts, which has now been turned into a book, a framework, and a workflow that developers are genuinely shipping with.
Let's go deep.
The Vibe Coding Crisis Is Real and Documented
First, let's establish that this isn't just one developer's bad night.
"Vibe coding" — the term coined by Andrej Karpathy in February 2025 — was named Collins Dictionary's Word of the Year for 2025. It entered the cultural lexicon as software development where you describe what you want, accept what the AI produces, and iterate via prompts rather than comprehension.
One year in, the vibes are measurably off.
The Productivity Paradox
In July 2025, METR ran a rigorous randomized controlled trial with experienced open-source developers. Real engineers, real codebases, real tasks. The result: developers using AI coding tools were 19% slower than those working without them. The same developers predicted they'd be 24% faster going in — and even after the experiment, still believed they'd been 20% faster.
They were measurably slower, and they didn't know it.
A broader analysis of vibe coding statistics found this pattern consistent: 95% of developers report feeling more productive while simultaneously producing lower-quality output. The explanation is straightforward — AI eliminates the easy, fast parts (scaffolding, boilerplate, repetitive patterns), which feels like a massive speed gain. But it quietly increases time spent on the hard parts: debugging unfamiliar code, hunting subtle logic errors in code you didn't write, and understanding hidden assumptions you never explicitly made.
The Code Quality Numbers Are Worse
A December 2025 analysis by CodeRabbit examined 470 open-source GitHub pull requests and found that AI co-authored code contained approximately 1.7x more "major" issues than human-written code. Specifically:
Logic errors: incorrect dependencies, flawed control flow — measurably elevated
Misconfigurations: 75% more common in AI-generated code
Security vulnerabilities: 2.74x higher in AI-generated versus human-written code
A separate Veracode study in October 2025 confirmed that while LLMs had become dramatically better at generating functional code over three years, the security profile of generated code had not improved at pace. Larger models weren't meaningfully better than smaller ones at generating secure output.
The Stack Overflow Developer Survey found 66% of developers experience the "productivity tax" — that specific frustration of AI-generated code that is almost, but not quite, right. Close enough to accept; wrong enough to break things later.
The CTO Survey That Should End the Debate
Final Round AI surveyed 18 CTOs in August 2025. 16 out of 18 (89%) reported experiencing production disasters directly caused by AI-generated code. One CTO's take: "AI promised to make us all 10x developers, but instead it's making juniors into prompt engineers and seniors into code janitors."
IBM reported a 60% reduction in development time for internal tools with AI assistance — but that's the sweet spot. Internal tools with low security bars, low maintenance expectations, and high bug tolerance. The moment you're building something that needs to be correct, secure, and maintained: the math changes.
What Vibe Coding Actually Gets Wrong
Before we get to the fix, it's worth being precise about the failure mode.
The problem isn't that Claude Code is bad at writing code. It's excellent at writing code. The problem is that it writes code to match what you described, not what you actually need — and the gap between those two things is where every 2 AM debugging session lives.
Dua Asif, writing in Activated Thinker (Feb 2026), described this precisely with the email validation story. She asked Claude to write an email validation function. Claude delivered — clean, with regex patterns, handling basic cases. Tests passed. Production deploy. Life was good.
Until customer support started getting complaints. The function rejected perfectly valid international email addresses, plus-sign filter addresses, addresses that followed RFC 5322 but didn't match the regex. The function worked exactly as asked. She just asked for the wrong thing.
"The quality of your output is directly proportional to the specificity of your input. Garbage in, garbage out applies to AI just as much as it does to traditional programming."
The hidden cost of vibe coding is you get what you request, not what you need. And that gap is invisible until production reveals it.
The deeper issue: vibe coding externalizes cognition into prompts and post-hoc evaluation. Traditional development front-loads thinking — you understand the problem deeply before writing code. Vibe coding moves that understanding after the code exists, which means you're evaluating assumptions you never consciously made. Review time goes up even as coding time goes down. Comprehension debt accumulates.
Prompt Contracts: The Method
Eveilleau's Prompt Contracts framework is, at its core, a simple reframe: stop treating Claude Code like a search engine and start treating it like an API you're writing a contract for.
When you call an external API, you don't just describe the vibes of what you want. You specify the endpoint, the expected inputs, the expected outputs, the error states, the edge cases, and the acceptance criteria. You define what success looks like before you make the call.
A Prompt Contract applies that same discipline to Claude Code interactions.
The Structure of a Prompt Contract
A well-formed Prompt Contract has five components:

Stack Declaration Be explicit and complete about your technical environment. Don't say "set up authentication." Say "implement authentication using Supabase with row-level security, in a Next.js 14 app with TypeScript strict mode, using the existing user table schema in schema.sql." This is the single change that prevents the Supabase-becomes-Firebase moment. Claude Code is not psychic about your stack. It will make reasonable assumptions. Those assumptions will sometimes be wrong in spectacular ways.
Success Criteria Define what "done" means in measurable terms. Not "handle edge cases" — that's a vibe. Instead: Must handle email addresses with non-ASCII characters Must handle plus-sign addressing (user+filter@domain.com) Must comply with RFC 5322 Must return a specific error type for invalid inputs (not throw) Must handle malformed API responses with trailing commas As Dua Asif notes: "What does 'works correctly' mean? Does it mean the function never raises exceptions? Does it mean it handles 99% of cases? Does it mean it fails gracefully with helpful error messages?" If you don't answer this in the prompt, Claude will answer it for you — and it may not answer it the way you need.
Explicit Constraints What can't it do? What must it not touch? Which patterns must it follow? Do not introduce new dependencies Do not modify the existing auth middleware Must use the existing error handling pattern from src/lib/errors.ts Performance: must complete in under 200ms for p99 The Anthropic API documentation itself instructs Claude Code: avoid over-engineering, don't add features beyond what was asked, don't add error handling for scenarios that can't happen. But "can't happen" is only knowable if your constraints are explicit.
Output Format Specification Specify the exact form of the output. A single function? A module? Including tests? With what kind of comments? In what file? Replacing existing code or alongside it? Vague output specs produce vague outputs.
Verification Criteria (The Self-Check Loop) This is the Prompt Contracts move that changes everything: ask Claude to verify its own output before delivering it. Eveilleau's framework includes what he calls the Verification Loop — prompting Claude to test its own code in the browser before you take delivery. The Amazon book description frames it as "the AI tests its own code before you take delivery." A simple version: append to every production-grade prompt — "Before responding, check your output against these criteria: [list your success criteria]. If any criterion is not met, revise before responding." Claude's ability to catch its own mistakes when explicitly asked is meaningfully better than its tendency to catch them unprompted. Build that into the contract. The Bigger Framework: Where Prompt Contracts Fit Prompt Contracts didn't emerge in a vacuum. The industry has been converging on the same insight from multiple directions. Spec-Driven Development GitHub announced a spec-driven development toolkit in September 2025. Martin Fowler published an analysis of it. It appeared in Thoughtworks Technology Radar Volume 33. AWS shipped Kiro — a spec-driven IDE — in public preview. The core idea: write a detailed specification before any code is generated. The spec includes requirements, architecture, API contracts, error handling, and edge cases. Heeki Park's write-up on using spec-driven development with Claude Code (March 2026) captures the experience of the convert: in earlier projects, he'd write a few quick sentences and start generating immediately, then course-correct repeatedly. After adopting specs: "most of my follow-up interactions were small tweaks rather than wholesale changes to the entire project." The pattern: upfront planning time pays compounding dividends in implementation quality. The CLAUDE.md System Claude Code natively supports a CLAUDE.md file — a persistent project constitution that Claude reads at session start. It functions as a standing prompt contract for the entire project: stack, conventions, folder structure, coding standards, commands, and non-negotiables. Nick Babich's guide on Claude Code project structure describes a well-formed CLAUDE.md as including project overview, architecture, tech stack, coding conventions (TypeScript strict mode, functional components, no default exports), folder structure, commands, and important rules for performance, accessibility, and testing. When your project has a CLAUDE.md, every prompt inherits that context automatically. You stop re-explaining your stack. You stop re-specifying your conventions. The contract becomes ambient. The GSD (Get Shit Done) Framework For Claude Code users who want to go further, the GSD build framework formalizes the spec-first approach with .spec.md files per feature. Instead of "Build me a login page", you create login.spec.md: # Specification: User Login Component ## Requirements
Input: Email and Password
Validation: Email must be valid format; Password > 8 chars
Action: Call /api/v1/login on submit
State: Show loading spinner during request ## Tech Stack
React + Tailwind CSS
Lucide Icons for eye/hide password toggle Then: claude "Implement the feature described in docs/specs/login.spec.md". The system ensures output isn't a snippet — it's a production-ready file built against a specification you reviewed before any code was generated. Prompt Contracts in Practice: Real Examples Here's the contrast between a vibe prompt and a contract prompt, using a real scenario. Vibe Prompt Add rate limiting to our API endpoints Contract Prompt STACK: Express.js API, Node 20, Redis (upstash), TypeScript strict. Existing rate limiting: none. Middleware pattern: see src/middleware/auth.ts for the pattern to follow.

TASK: Implement rate limiting middleware for all /api/* routes.

SUCCESS CRITERIA:

100 requests/minute per IP for unauthenticated routes
1000 requests/minute per authenticated user (use existing auth context)
Returns 429 with Retry-After header when limit exceeded
Rate limit headers (X-RateLimit-Limit, X-RateLimit-Remaining, X-RateLimit-Reset) on all responses
Graceful degradation: if Redis is unavailable, allow requests through (log warning)

CONSTRAINTS:

Do not modify existing auth middleware
Do not introduce dependencies beyond upstash/ratelimit (already in package.json)
Must work in edge runtime (Vercel)

OUTPUT: Single middleware file at src/middleware/rateLimit.ts + update to src/app.ts showing usage. Include 3 test cases.

VERIFY: Before responding, check that the Redis unavailability case is handled and that the Retry-After header is correctly calculated from the window reset time.
The second prompt takes 90 seconds to write. It produces something that actually goes to production. It also becomes documentation — when you come back to this code in three months, the spec is right there.
As Dua Asif noted: "The prompt contract became documentation."
When Not to Write a Contract
Prompt Contracts have a cost: they take time to write. For casual work, they're overkill.
The rule of thumb that's emerged from practitioners: write a contract when the code matters. When it's going to production, when other people will maintain it, when bugs would be costly, when it touches security or payments or auth.
Don't write a contract for:
Explaining a concept
Refactoring a small, isolated function you're going to review line-by-line
Throwaway scripts you'll delete in an hour
Exploring or prototyping to understand a new technology
Do write a contract for:
Any feature that touches user data
Any API integration
Any auth or permissions logic
Any code that will outlive the current sprint
Any code that other team members will inherit
The threshold for "code that matters" is lower than most developers initially think. That "quick script" has a way of becoming a critical pipeline six months later.
The Senior Developer Advantage
One of the most consistent findings in vibe coding research: senior developers (10+ years) report 81% productivity gains from AI coding tools, while junior developers show mixed or negative results.
The explanation: AI tools amplify existing judgment. Senior engineers can evaluate what AI produces — they recognize when an architecture decision is wrong, when a security pattern is suspect, when a function is doing too much. They use AI for the mechanical parts while retaining oversight on the judgment calls.
Junior developers lack the reference points to evaluate AI output. They accept code they can't fully evaluate, which means they can't catch what the AI got wrong.
Prompt Contracts partially bridge this gap. By forcing explicit success criteria and constraints before generation, you build in the checkpoints that a senior engineer would apply mentally. The contract externalizes the judgment that experience normally provides implicitly.
The Productivity Tax and How Contracts Reduce It
Stack Overflow's data: 66% of developers experience the productivity tax — "code that is almost, but not quite, right." That "almost" is the most expensive word in software development. It's the bug you can't find because the code looks right. It's the edge case that passes every test you wrote because you didn't know to write that test.
A research analysis of vibe coding statistics put it precisely: vibe coding doesn't eliminate engineering effort — it redistributes it. Speed gains in early development are real. They're counterbalanced by increases in review burden, defect risk, and organizational knowledge decay.
Prompt Contracts specifically attack the knowledge decay problem. When every production prompt includes a stack declaration, success criteria, and constraints, you accumulate a library of specifications that document what the code was supposed to do — not just what it does. That's documentation that writes itself.
The Bottom Line for Developers in 2026
The data has converged on something the Prompt Contracts framework formalized in practice:
AI code generation is not a replacement for engineering judgment. It's an amplifier of it.
The developers who ship reliably with Claude Code in 2026 are not the ones typing natural language and hoping for the best. They're the ones who treat Claude Code as a powerful junior engineer who executes brilliantly but needs precise briefs. They specify the stack, define success, constrain the scope, and build verification in.
Vibe coding will get you a beautiful Firebase implementation when you asked for Supabase.
A Prompt Contract will get you exactly what you needed — even the edge cases you forgot you needed.
The risotto might be delicious. But at 2 AM, you wanted pizza.
Resources & Further Reading
Philippe Eveilleau — Prompt Contracts on Medium (original article)
Philippe Eveilleau — Prompt Contracts: The Book on Amazon
Dua Asif — I Stopped Vibe Coding and Started Prompt Contracts (Activated Thinker, Feb 2026)
Wikipedia — Vibe Coding — METR study, CodeRabbit data, industry reaction
Hashnode — The State of Vibe Coding in 2026
Pixelmojo — The AI Coding Technical Debt Crisis
Bloomberg Businessweek — Claude Code and the Great Productivity Panic of 2026 (Feb 2026)
Heeki Park — Using Spec-Driven Development with Claude Code (March 2026)
Thoughtworks — Spec-Driven Development: 2025 Emerging Practice
Anthropic — Claude Code Best Practices
Anthropic — Claude Code Prompting Best Practices
What does your current AI prompting workflow look like? Are you writing specs before you generate, or still iterating from vibes? Drop it in the comments — genuinely curious where the community has landed.

Is Anthropic Quietly Building What Bitcoin Always Promised?

Mashraf Aiman — Wed, 11 Mar 2026 07:23:36 +0000

Is Anthropic Quietly Building What Bitcoin Always Promised? A Developer's Deep Dive

"Anthropic isn't trying to kill Bitcoin. That would require them to care about it. They're too busy building something that accidentally does the same job better."
— Mohit Aggarwal, Medium (March 2026)

A viral piece by Jose Crespo, PhD, titled "Anthropic is Killing Bitcoin" has been circulating since February 2026 — collecting thousands of reactions, rebuttals, and LinkedIn reposts. The thesis is bold: Anthropic has accidentally built an AI-native currency through its token-based API pricing, one that outperforms Bitcoin by six orders of magnitude in the tasks that actually matter for a machine economy.

Is this hype? Is it right? Is it somewhere in the middle?

As developers, we're uniquely positioned to cut through the noise. Let's go data-first.

The Argument, Distilled

The Crespo article makes three core claims:

Capital is already deserting Bitcoin infrastructure in favor of AI compute contracts — and the former builders of crypto are signing the checks.
Anthropic's API credit system functions as a de facto machine-to-machine currency — faster, cheaper, and more scalable than anything in the crypto stack.
The "total machine economy" — a world where AI agents transact autonomously — needs a different kind of money, and the crypto stack isn't it.

Let's examine each with real data.

Claim 1: Capital Is Fleeing Crypto for AI Infrastructure

This is the most empirically defensible part of the thesis, and the numbers are striking.

The Mining Exodus

According to CoinShares' 2026 Bitcoin Mining Outlook, mining revenue is projected to drop from ~85% of total revenue in early 2025 to under 20% by end of 2026 for companies that have successfully pivoted to AI contracts. The same companies that built crypto's physical backbone are now signing decade-long AI infrastructure deals.

By October 2025, bitcoin miners had announced $65 billion in contracts with major technology companies and cloud providers — a figure that CoinShares describes not as a hedge, but as a structural exodus. Companies that have made the switch can generate 80–90% operating margins from AI deals, versus the notoriously thin margins of Bitcoin mining.

Some notable examples from publicly traded miners:

Core Scientific (CORZ) — Signed 12-year contracts with CoreWeave worth an estimated $6.7 billion, providing 200+ megawatts of GPU hosting capacity.
Bitfarms — Announced a full exit from Bitcoin mining by 2027 to operate exclusively as an AI data center operator.
Bitdeer Technologies — Reduced its BTC holdings to zero to fund AI data center expansion.
Riot Platforms — Sold $200 million worth of Bitcoin in the final two months of 2025, treating it as a funding tool for AI capex.

A separate analysis published in February 2026 documented a 400% increase in sector-wide data center capital expenditure between March 2025 and February 2026, driven entirely by AI infrastructure buildout. As one Q1 2026 earnings call put it bluntly: Bitcoin mining "doesn't make a lot of sense" at current hashprices compared to the returns available in AI infrastructure.

The VC Capital Ratio

Crunchbase's end-of-year 2025 report confirmed another number Crespo cites: AI captured $211 billion in venture funding in 2025, up 85% year over year from $114 billion in 2024. That makes AI the dominant sector for venture capital — representing roughly 50% of all global VC deployment.

Crypto, by comparison, raised an estimated $17–18 billion in venture funding across 2025 — meaningful, but less than 10% of what AI attracted. The ratio Crespo references (~12:1 in favor of AI per invested dollar) is directionally accurate.

The physical layer of Bitcoin is quietly becoming the physical layer of AI. That is not speculation — it's a signed contract.

Claim 2: API Tokens as AI-Native Currency

This is where the argument gets more interesting — and more contested.

The claim: Anthropic's API credit system already powers billions of machine-to-machine microtransactions daily — functioning as a currency that is faster, cheaper, and infinitely more scalable than Bitcoin.

Let's break down the mechanics from a developer perspective.

How Token Pricing Actually Works

As of early 2026, Anthropic's Claude API is priced as follows (in USD per million tokens):

Model	Input	Output
Claude Haiku 4.5	$1.00	$5.00
Claude Sonnet 4.5	$3.00	$15.00
Claude Opus 4.5	$5.00	$25.00

With prompt caching enabled, cache reads drop to 0.1× base input cost — making repeated context retrieval extremely cheap. Batch processing APIs reduce costs by up to 90% for non-time-sensitive workloads.

A typical small agentic API call — say, 1,000 input tokens and 500 output tokens — costs roughly $0.0000035 to $0.000013 depending on model. That's sub-cent micropayments at scale, processed instantly, with no gas fees, no mempool, no 10-minute confirmation windows.

For comparison: Bitcoin's average transaction fee has ranged from $1.50 to $15+ in recent years, with confirmation times measured in minutes. For machine-to-machine micropayments at millisecond latency and sub-cent denominations, the architectural mismatch is real.

The "Currency" Critique

But here's what the rebuttals get right — and they are worth reading. The Medium piece from Dark Energy Articles (published March 2026) makes a sharp counterpoint: Anthropic's API credits are not a currency in any meaningful sense.

They have no:

Transferability — you can't send your Claude credits to another user or agent.
Interoperability — they only work within Anthropic's closed ecosystem.
Decentralization — Anthropic can revoke, reprice, or discontinue them at will.
Store of value — unused credits depreciate as pricing changes.

Calling API credits a "currency" conflates a closed-loop billing system with an open monetary network. Bitcoin, whatever its speed and cost limitations, is permissionless, censorship-resistant, and operates without any single company's approval.

What Anthropic actually has is a highly optimized internal unit of account for AI compute — not a currency.

The X402 Protocol: The Real Story Nobody's Covering

Here's what both the viral piece and most of its rebuttals missed: the x402 protocol, a decentralized, blockchain-based micropayment standard built specifically for AI agent-to-agent transactions.

Developed in 2025 and adopted quickly by Google Cloud, AWS, and Anthropic, x402 enables real-time, low-cost micropayments for API access, data, and compute — designed explicitly for the machine-centric economy both sides of this debate are arguing about.

This is important: the actual convergence isn't "Anthropic replaces Bitcoin." It's AI infrastructure adopting blockchain-native payment rails for the agentic layer. The real fight is over which settlement layer becomes the standard for autonomous AI commerce — and that race is genuinely open.

Claim 3: The Total Machine Economy Needs Different Money

This is the most forward-looking part of the thesis, and also the most debatable.

The core insight is correct: agentic AI systems that autonomously pay for compute, data, and services need a different payment primitive than anything currently dominant. Credit card rails are too slow and too human-permission-dependent. Bitcoin is too expensive and too slow for sub-cent micropayments. Ethereum gas fees make microtransactions economically absurd.

What the machine economy actually needs:

Sub-millisecond settlement for real-time agent coordination
Sub-cent denominations for compute metering
Programmable, conditional payments (pay-for-outcome, not pay-for-input)
Cross-provider interoperability so agents aren't locked into one cloud

None of the current major players — not Anthropic's API credits, not Bitcoin, not ETH — perfectly satisfies all four. The space is genuinely unsolved.

What Claude Opus 4.6 Actually Did to Markets

One piece of context Crespo references: in early February 2026, Anthropic unveiled Claude Opus 4.6, and the market reaction was telling. Software stocks dropped despite strong earnings. Bitcoin fell as investors fled to stable assets. IBM dropped 11% weeks later when Anthropic announced Claude Code could automate COBOL modernization.

These aren't just "AI hype" moves. They're the market pricing in something real: AI is eating the application layer, and companies whose moats were "specialized software knowledge" are facing an existential repricing. Anthropic's annualized revenue reached $3 billion by summer 2025, up from $1 billion in late 2024 — a growth rate that validates the infrastructure thesis.

The Developer Verdict: What's Real, What's Hype

After pulling the data, here's the honest breakdown:

What Holds Up

The infrastructure migration is real and documented. $65B in signed contracts, 400% capex increase, miners zero-ing out BTC holdings to fund GPU buildouts. This is happening.
The capital ratio is real. For every dollar going into crypto infrastructure, roughly $12 went into AI in 2025. The physical layer is being reallocated.
API microtransactions are architecturally superior for AI-to-AI payments. The latency and cost comparison is not close if you're building agentic systems.
The machine economy is coming. Autonomous agents that need to pay for resources is a solvable engineering problem, and it's being worked on now.

What's Overstated

Anthropic's API credits are not a currency. They're a billing system. Closed, non-transferable, controlled by a single private company. Calling them a "monetary system" is a category error.
Bitcoin isn't dead — it's evolving. CoinShares' own 2026 outlook projects BTC at $110,000–$150,000 depending on macro conditions. Stablecoin volumes now rival Visa and Mastercard combined. Bitcoin's role is shifting toward institutional settlement and store of value, not micropayments — and that may be exactly right.
The "six orders of magnitude" framing is misleading. Comparing Bitcoin transaction throughput to Anthropic API call volume is comparing apples to fusion reactors. They're solving different problems.

What's Genuinely Uncertain

Which payment layer wins for the agentic web. X402, Solana micropayments, Layer-2 solutions, or something not yet built — the race is real and genuinely open.
Whether Anthropic's infrastructure lead is durable. OpenAI, Google DeepMind, and others are building equivalent infrastructure. The "accidental monetary system" argument depends on Anthropic maintaining architectural centrality, which isn't guaranteed.

What This Means If You're Building

If you're shipping AI-native products in 2026, here's the practical takeaway:

1. Design your architecture for compute-as-currency from day one.
Your agents will need to pay for resources. Build payment abstractions into your agent framework now, not after. Assume the settlement layer will change.

2. Watch x402 closely.
It's the most credible candidate for becoming the standard micropayment protocol for AI agents. AWS, Google Cloud, and Anthropic are already in. If this becomes the HTTP of AI payments, early movers will have significant advantage.

3. Don't bet on one provider's credit system as your payment primitive.
Anthropic can (and does) change pricing, rate limits, and model availability. If your business logic is coupled to a specific provider's billing unit, you're one pricing announcement away from a restructure.

4. The infrastructure layer is where the real money is flowing.
$65B in signed contracts, $211B in VC, 400% capex growth. If you're building infrastructure tooling, observability, or orchestration for AI workloads — that's where capital is pointing.

Sources & Further Reading

Jose Crespo, PhD — "Anthropic is Killing Bitcoin" (AI Advances, Feb 2026)
Dark Energy Articles — "No, Anthropic Isn't Killing Bitcoin" (Medium, Mar 2026)
Mohit Aggarwal — "Anthropic Is Building What Bitcoin Promised — Without Trying To" (Medium, Mar 2026)
CoinShares — 2026 Bitcoin Mining Outlook
Crunchbase — Global Venture Funding in 2025
CoinDesk — End of Bitcoin HODL: Miners Going All-In on AI
Fortune — If the Recent AI and Crypto Shocks Upset You, You're Tracking the Wrong Cycle
OECD — Venture Capital Investments in AI Through 2025
Insights4VC — Bitcoin Mining's AI Pivot: 2026 Thesis Update

Found this useful? Drop a comment with what payment layer you're building on for your agents — genuinely curious where developers are landing on this.

Olio AI: Promptless AI Product Photography – Built with GitHub Copilot CLI

Mashraf Aiman — Sun, 15 Feb 2026 02:33:02 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

Olio AI (tryolio.app) is an AI-powered product photography tool that transforms simple uploaded product photos into stunning, production-ready visuals in seconds. No prompts needed, just upload your images, and Olio generates studio-quality shots with multiple angles (front, side, top, lifestyle, detail), variations (colors, materials, packaging, SKUs), and high-converting e-commerce-ready outputs.

Basically It's a huge problem for SME Business around the planet. I saw brands struggling with studio, photographer & model setups, thinking about creative advertisement, social media post, spending up to $700-$1000 for just photographs. In Olio AI we cut the price to ~$0.60 & time to 90 seconds.

It's designed to eliminate the need for expensive photographers, models, or studio setups, saving brands up to 100x on costs while delivering 99% accurate, social-media-optimized images for Shopify, Amazon, ads, and more. Categories include fashion, cosmetics, jewelry, gadgets, food & beverage, home goods, and beyond.

This project is already live with 20+ beta users, and it's gaining traction—it's a January Finalist in HackerNoon’s Proof of Usefulness Hackathon, earning a 43 Proof of Usefulness score and standing out among 21,000+ submissions from giants like Apple, Nvidia, Microsoft, Google, Amazon, Meta, and SpaceX. We're building real utility in the e-commerce ecosystem!

(For more: tryolio.app, HackerNoon feature)

Demo

Live app: https://tryolio.app
Dashboard (beta/testing access): https://dashboard.tryolio.app

Test Credentials (for judges & reviewers):

Email: sheuli8642@gmail.com

Password: zaz123456

Here's how it works in action – step-by-step for stunning results:

Sign in with the test credentials above.
Upload one or more raw product images (JPG/PNG; multiple angles = even better outputs).
Choose Product Shot as category.
Select Olio Magic Mode + Olio Pro Model for the highest-quality, production-ready visuals.
(Optional – highly recommended) Open the Advanced tab to fine-tune: select angles (front, side, top, lifestyle, detail), prompt for variations (colors, materials, SKUs, packaging), and more.
Click generate → wait ~90 seconds → receive commercial-grade, 4K-ready images optimized for Shopify, Amazon, ads, and social media.

Note: In rare beta cases a quick page reload may be required during processing (we're polishing this flow - GitHub Copilot CLI has already helped us squash several related bugs).

Once generated, you get full control:

Zoom in for pixel-perfect inspection
Regenerate individual shots
Create instant new variations of the same product
Download in high-resolution HD quality

We also included an in-app reporting system so you can directly flag any issues to our team, which resolves them quickly to keep improving. Use Remix for a simple text prompt for small tweaks (reposition items, remove objects, adjust lighting, etc.)

Admin Panel (not publicly accessible for security):

This secure backend lets us monitor generations, view real-time stats & analytics, manage beta-user credits, review reports, and configure system settings.

If the judges would like a guided demo or temporary access for evaluation, please email teamennovat@gmail.com; We are happy to provide secure credentials or a walkthrough of Admin Panel as well.

For now, here are preview screenshots of the admin interface:

Olio is live in beta with 20+ active users already creating real commercial visuals — try it yourself with the test account and see how it turns ordinary uploads into professional-grade photography in under 90 seconds!

My Experience with GitHub Copilot CLI

We heavily used GitHub Copilot CLI together with Copilot in VS Code to build Olio AI, and the development journey unfolded in clear stages.

At first, I used Antigravity for fast prototyping and brainstorming ideas. A few days in, I ran into real roadblocks; complex image processing, backend integrations, upload flows, and iterative debugging were hard to perfect. That’s when I switched to VS Code Copilot. It gave great in-editor completions and helped write code quickly, but it still struggled with multi-file changes, terminal workflows, and deep repo-wide context.

Then I started using GitHub Copilot CLI and the combination of VS Code Copilot + CLI was absolutely mind-blowing.

The CLI became my intelligent terminal companion. It debugged tricky scripts with precision, generated clean boilerplate for services, suggested powerful optimizations for our generation pipelines, handled Git operations flawlessly (branches, commits, PRs), and even executed multi-step agentic tasks with my approval. It felt noticeably more precise, made far fewer mistakes, understood my entire codebase better (especially across files), and let me iterate insanely fast without ever leaving the terminal.

What I loved most:

Stronger context awareness - it saw the whole project, not just the open file.
Agentic power - it planned and ran complex sequences (refactors, automation scripts, repo interactions) like a real collaborator.
Zero context-switching - everything happened right in the terminal.
Speed & quality - repetitive grunt work vanished; I focused purely on building the core AI magic.
It also made my product's internal AI, context engineering & Prompt engineering perfect.

In Olio specifically, Copilot CLI:

Accelerated setup of our promptless generation engine
Sharpened upload & error-handling logic
Seamlessly wired up analytics endpoints
Quickly diagnosed and fixed beta quirks (like occasional reloads)

What could have taken weeks of tedious manual work became focused, high-quality progress in just days. Olio AI literally became the child of this autonomous, agentic CLI workflow—I built a production-ready product in one intense week thanks to it.

GitHub Copilot CLI was the game-changer. It delivered faster development, cleaner code, and real momentum to our e-commerce visual generation vision. I can’t imagine shipping Olio this polished without it.

My Teammate: Istiaque Zaman (@istiaquez )
Co-founder, Olio

Mashraf Aiman (@mashraf_aiman )
Founder, Olio

Olio AI beat 21k Companies including FAANG

Mashraf Aiman — Sat, 14 Feb 2026 03:18:32 +0000

Competed against Spotify, Google, Meta, Apple, spaceX, Microsoft, Amazon, Oracle, Nvidia, Quillbot, Huawei, Okta & 21k more companies, products, and projects. Still my Olio AI became product of the week in Hackernoon's Proof of Usefulness Reports Hackathon.

Mashraf Aiman
Founder, Olio

Istiaque Zaman
Co-founder, Olio

How to Turn Raw Product Photos Into Studio-Quality Images with AI

Mashraf Aiman — Sat, 31 Jan 2026 03:30:13 +0000

Struggling with dull, poorly lit raw product photos that don't sell? In 2026, AI product photography enhancement lets you turn raw product photos into studio-quality images in minutes—no expensive lights, backdrops, or retouching skills required. Simply upload your basic shots (even from a phone), and advanced AI tools handle lighting fixes, background swaps, shadow additions, detail sharpening, and professional staging for e-commerce-ready visuals that boost conversions.

This step-by-step guide uses Olio AI—the simplest no-prompt tool—to transform everyday photos into polished, high-converting assets. Brands save 10x time and up to 100x costs compared to traditional studios while getting natural, production-grade results without "AI weirdness" or artifacts.

Why Use AI to Turn Raw Product Photos Into Studio-Quality Images?

Raw photos often look flat: bad lighting, distracting backgrounds, low resolution, or uneven focus kill sales. Professional studio shoots cost $50–$500+ per image and take days. AI changes that instantly:

Automatic lighting & shadow fixes for depth and realism
Background removal/replacement with pro styles (clean white, lifestyle, luxury)
Detail enhancement: sharper textures, better colors, no blur
Variations in angles, moods, and staging for ads/catalogs/social
Scalable for hundreds of SKUs without reshoots

Result? Higher-quality images that look shot in a $10K studio—driving better click-throughs and sales on Shopify, Amazon, or Etsy.

Step-by-Step: How to Turn Raw Product Photos Into Studio-Quality Images with Olio AI

Olio AI excels at dead-simple workflows: upload → configure → generate. No complex prompts or editing needed. Here's the exact process:

Step 1: Prepare and Upload Your Raw Product Photos

Start with clear raw shots—natural light is best, but any phone/camera photo works. Tips for best results:

Center the product on a plain(ish) background
Shoot multiple angles if possible (front, side, 45°, top-down)
Avoid heavy shadows or glare initially (AI fixes them)
Use JPG/PNG format

Go to tryolio.app, sign up/log in, and drag-drop your image(s). Olio auto-processes—no descriptions required. This upload simplicity makes it one of the fastest ways to turn raw product photos into studio-quality images.

Step 2: Configure Settings for Studio-Level Polish

After upload, customize easily:

Mode Selection: Choose Product Photoshoot for standard items (gadgets, beauty) or Mannequin Mode for apparel/fashion (natural on-model visuals without real models).
Background Options: Pick from pro styles like E-commerce Clean (pure white for listings), Studio Professional (softbox look), Lifestyle Modern (real-world appeal), Minimalist Zen (clean elegance), Rustic Natural (organic vibe), Marble Luxury (premium feel), Industrial Urban (edgy), Bright Fresh (vibrant), Dark Moody (dramatic), Botanical Garden (fresh), Culinary Kitchen (food-related), Tech Modern (sleek gadgets).
Olio Pro / Olio Studio Models: Enable for realistic human elements in lifestyle shots (hands, figures) or stick to Pro for pure product focus.
Aspect Ratio: Select square (1:1 Instagram), vertical (4:5 stories), landscape (16:9 ads), or custom for platforms.
Advanced Tab:
- Camera Angles: Eye Level (standard), Top View (flat lay), Low Angle (heroic), Side View (profile), Three Quarter (dynamic), Close Up (details).
- Custom Prompting (optional): Add minor tweaks like "softer shadows" or "higher contrast"—most users skip for instant results.

Olio Magic Mode auto-applies enhancements: balanced lighting, realistic shadows/reflections, sharpened details, color correction—no manual sliders needed. Generate multiple variations at once for testing.

Step 3: Generate, Review, and Export Studio-Quality Images

Click Submit—Olio processes in seconds to minutes, delivering up to 4K resolution images with pro-level quality.

Review outputs: natural textures preserved, no distortions, perfect for catalogs/ads/social. Download individually or batch-export. If needed, tweak one setting and regenerate (credits are cheap at scale).

Use directly on your store or pair with Canva/CapCut for final ad touches.

Pro Tips to Maximize Studio-Quality Results Every Time

To get the absolute best when using AI to turn raw product photos into studio-quality images:

Start with decent raw shots—good initial exposure helps AI shine.
Use Olio Magic Mode as default for automatic pro polish.
Test backgrounds/angles—e.g., Low Angle + Marble Luxury often wins for premium feel.
Batch process catalogs for consistency across products.
Compare before/after: Share transformations on social to build trust.
Avoid over-custom prompts—let AI handle natural realism.

Users see massive improvements: flat raw shots become conversion machines.

Common Mistakes to Avoid in AI Product Photo Enhancement

Steer clear of these pitfalls:

Poor raw quality (extreme blur/low light)—AI fixes a lot but not miracles.
Over-editing prompts—leads to unnatural results; keep simple.
Ignoring aspect ratios—match platform needs for best display.
Skipping variations—test multiple outputs to find winners.

Avoid these, and your images will consistently look like high-end studio work.

Ready to Upgrade Your Product Photos?

Stop settling for mediocre raw shots—turn raw product photos into studio-quality images with AI today. Olio AI makes it effortless: upload, configure, get pro results that sell.

Visit tryolio.app now—start with a free test upload (limited) and upgrade from $19/mo. Your products deserve visuals that wow.

Tried this process? Share your before/after in the comments—we love seeing transformations!