DUMB DEV Community: Mashraf Aiman

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!

tryolio.app is publicly available now

Mashraf Aiman — Wed, 14 Jan 2026 07:29:22 +0000

Hi everyone 👋
Olio is officially live at https://tryolio.app

Olio lets you generate commercial, social media, and billboard-ready product photography from a single product image. No photographers. No studios. No complex prompts. Just upload and get clean, premium visuals that are actually usable in real-world marketing. Transforming $50 to $0.50 per product photography!

Use code OLIO10 for a discount.

Want a free demo?
Reach out at teamennovat@gmail.com

The focus is simple:
modern, production-ready, premium, shareable product photography built for e-commerce brands, creators, and businesses that need speed and consistency without sacrificing quality.

Olio supports mannequin-based and product-only visuals, making it especially useful for brands that want clean, modest, and ethically aligned imagery without compromising on global standards. At launch, it has already smashed all the existing tools and made a huge history in the industry! What's your opinion?

If you’re working with products and tired of slow, expensive photoshoots, this might be worth a look.

👉 Try it now: https://tryolio.app

How to build a $5,000/Month AI System with ChatGPT + Gumroad

Mashraf Aiman — Tue, 13 Jan 2026 03:23:02 +0000

You’ve probably seen “Make $5K/month with AI!” headlines everywhere (and most of them are half-baked noise). But here’s the honest truth: making real income with AI products in 2026 isn’t about hype — it’s about solving problems that people already pay to fix. :contentReference[oaicite:0]{index=0}

In this post I’m breaking down the strategy I’m using — inspired by practical guides and real frameworks — to go from idea → product → $5,000/month via ChatGPT + Gumroad.

No theory. No motivational slogans. Just what actually works.

What Real AI Products Look Like in 2026

The old ChatGPT-prompt bundle and generic ebook market is dead. Those first-wave products made sense when AI was new. Today, customers care about utility, outcomes, and workflows:

• Tools that save time

• Products that prevent costly mistakes

• Things that help people act with confidence

• Systems that organize complexity

AI can be the engine behind the product — but utility is what sells it. :contentReference[oaicite:1]{index=1}

If your product doesn’t solve a measurable problem, it won’t hit $5K/month repeatedly.

Step 1: Start With a Real Problem (Not A Cool Idea)

This is where most people fail.

Don’t start with:

“Let’s make a cool AI product.”

Start with:

What is one frustrating workflow or task that people hate doing?

For example:

Freelancers who lose hours to repetitive proposals
Solopreneurs who can’t manage leads or follow-ups
Creators who waste time formatting and editing

The biggest mistake I see is launching products about AI rather than products that use AI to solve real pain.

Your goal is clarity:

“What single result does this product deliver?”

That’s the foundation of repeatable demand.

Step 2: Define the Outcome Before You Build

Pick a specific outcome that:

is measurable
people would pay to avoid doing themselves
can be delivered in a digital format

Micro example:

“A Notion template plus SOPs that organizes client onboarding so users never miss tasks.”

That’s better than:

“A productivity prompt bundle.”

Why it matters:
Pricing products backward works. If you price at $99–$149, you only need 35–50 sales/month to hit $5,000. That math lets you plan, not guess. :contentReference[oaicite:2]{index=2}

Step 3: Use ChatGPT to Structure the Product

AI doesn’t replace your domain knowledge — it fast-forwards the execution.

Use ChatGPT to:

turn messy workflows into checklists and SOPs
write clean content drafts
generate examples and templates

Always edit the output yourself before packaging. The difference between a generic prompt dump and a useful tool is curation.

A simple workflow might look like:

Ask ChatGPT to outline a template for the problem.
Expand each section with examples.
Convert into a PDF, Notion workspace, spreadsheet, or tiny course.
Add simple onboarding instructions.

This is productization, not automation.

Step 4: Publish on Gumroad (and Tell People What It Does)

Gumroad is the platform of choice for many because:

It’s simple to launch
Payments are handled
You control pricing & bundles

But your listing must be educational:

Clear problem statement
What’s included
Who it’s for
What outcome users will get

People don’t buy AI.

They buy a promise of outcome.

If your product page doesn’t answer:

“What will I have done after buying this?”

You’re missing the sale.

Step 5: Build an Audience Through Education

This isn’t optional.

You don’t need millions of followers. What you do need is one audience where your product solves a clear pain.

Here’s how people are doing it without paid ads:

Post useful how-to threads on X, Threads, Reddit
Share short case studies of how your system solves real pain
Turn tutorials into Medium posts or YouTube shorts
Use email newsletters to educate and convert

Example pattern:

“Here’s how I went from lost proposals to organized wins in 30 minutes.”

This kind of story converts because it teaches and sells.

Step 6: Add Small Upsells (Without Being Sketchy)

Most first products are “core solutions” — but you can add:

Advanced templates
Custom setup services
Mini coaching calls
Community access

Upsells increase customer value without needing explosive traffic.

If a user pays $99 for the base product, offering a $49 upsell to automate part of the workflow can significantly boost your revenue per buyer.

Real People, Real Systems

Across Reddit and real maker communities:

People launch simple AI digital products in a day or weekend and get actual downloads within 24–48 hours. :contentReference[oaicite:3]{index=3}
Some creators have scaled up to low-side passive revenue with consistent effort. :contentReference[oaicite:4]{index=4}
You don’t need a personal brand or paid traffic to start seeing results — you need clarity + simple execution.

The trend is clear: AI accelerates execution — but the actual value still lies in human problem structuring & polish.

What Most Guides Get Wrong (And How To Avoid It)

AI is not your product

The product is the outcome your user is paying for.
More content ≠ more money

Stop chasing views; focus on conversion-ready education.
Automation doesn’t sell itself

Human framing + context sells.
Perfection kills progress

Launch early, gather feedback, iterate.

AI speeds you up — but it doesn’t replace the product muscle you build by doing hard, obvious work well.

Final Thoughts: Start With Solve, Not Hype

In 2026, the serious AI business builders aren’t selling prompts and buzzwords.

They’re selling solutions to problems where people already pay real money — and they use AI to build, not to dress up their products.

If you follow a simple system:

pick a real pain → define outcome → structure with AI → publish + educate → iterate You’re already doing 80% of what most guides skip.

That’s how $5,000/month systems are actually built.

And that’s how they scale.

Want a Practical Checklist?

Reply with “checklist” and I’ll give you a copy-paste, actionable step list you can follow in your own business.

Stanford Just Killed Prompt Engineering With 8 Words

Mashraf Aiman — Sun, 14 Dec 2025 03:59:03 +0000

Stanford Accidentally Killed Prompt Engineering With One Simple Trick

And why ChatGPT sounding boring was always your fault, not the model

Tags: #ai #chatgpt #promptengineering #llms #machinelearning

I asked ChatGPT to tell me a joke about coffee.

Same joke. Every time.

I changed the wording.

I raised the temperature.

I added creative instructions.

Nothing changed.

That was the moment I realized something uncomfortable. The model was not stuck. I was.

And a Stanford paper just proved it.

The real reason AI feels repetitive

Most people assume AI lacks creativity. That is wrong.

Large language models are trained to be consistent, safe, and statistically optimal. When you ask for one answer, the model does exactly what it is designed to do. It gives you the most likely response and stops.

It is not failing.

It is obeying.

The problem is that single-shot prompts collapse possibility too early.

The paper that changed everything quietly

Stanford researchers published a paper introducing a technique called Verbalized Sampling.

No retraining.

No fine-tuning.

No expensive compute.

Just a small shift in how you ask questions.

Instead of requesting one output, you ask the model to expose multiple possibilities and explain their likelihood.

That is it.

The eight words that unlock hidden creativity

Instead of this:
Tell me a joke about coffee.
You ask this:
Generate 5 jokes about coffee with their probabilities.

That tiny change forces the model to explore instead of collapsing into one safe answer.

You are not adding randomness.

You are surfacing options the model already had.

Why this works at a technical level

Internally, language models evaluate many valid continuations. Normally, they select the highest probability path and discard the rest.

Verbalized sampling prevents that early collapse by requiring:

Multiple candidate generations
Explicit comparison between outputs
Reasoning about likelihood instead of certainty

The model already knows these alternatives exist. You are simply asking it to show its thinking.

The results were not subtle

The Stanford study reported:

Around 2x increase in creative diversity
Roughly 66 percent recovery of lost variation
No meaningful drop in accuracy or safety
Stronger gains in larger, more capable models

That last point matters. The better the model, the more unused creativity it was hiding.

Why this breaks most prompt engineering advice

A lot of prompt engineering is cosmetic.

Be more creative.

Act like a poet.

Think outside the box.
None of that changes how the model samples internally.

Verbalized sampling does.

It works across models.

It works immediately.

It does not require special system prompts.

That should make anyone selling prompt templates uncomfortable.

Practical prompts you can use today

Creative writing:
Generate 4 opening paragraphs for a sci-fi novel and include probability estimates.

Product ideation:
List 6 fintech startup ideas with brief explanations and relative likelihood.

Marketing copy:
Create 5 headline options for this landing page and rank them by confidence.

Decision making:
Provide 3 possible solutions to this problem and explain how likely each is to succeed.

Once you try this, regular prompting feels broken.

The uncomfortable takeaway

If one small wording change unlocks this much latent capability, how much intelligence are we wasting every day?
We keep blaming AI for being shallow.

But we keep asking shallow questions.
This was never about smarter models.
It was about asking in a way that aligns with how they actually think.

Final thought

Prompt engineering is not clever phrasing.

It is understanding how probability works.
Once you do, the ceiling moves fast.
If this changed how you prompt, test it yourself. That is the only proof that matters.

Mashraf Aiman
AGS NIRAPAD ALLIANCE
CTO Zuttle

How to Stop Your AI Agent From Making Unwanted Code Changes

Mashraf Aiman — Thu, 11 Dec 2025 10:53:34 +0000

AI agents often behave like brilliant but overly enthusiastic interns — eager to help, but sometimes too eager. Even with clear instructions, they’ll occasionally decide, “Let me fix this other thing too…” and suddenly your codebase contains changes you never asked for.

This happens because modern LLMs are trained to be helpful. But in software projects, “extra helpful” can quickly turn into chaos. I’ve had situations where a tiny, unintended edit was hidden inside seventy modified files. Reviewing that manually through git diff is painful, and asking the agent to revert it is even worse — it doesn’t remember your file state, only the conversation.

The solution isn’t complicated. It’s classic engineering discipline: version control. We already commit early and often, so why not enforce the same rules on our AI agents? Here’s the workflow I use with goose to guarantee clean snapshots and easy rollbacks.

1. Set Up Version Control

Use GitHub.

I prefer the GitHub CLI (gh) because goose interacts with it perfectly.

The GitHub MCP Server is a solid alternative if that fits your workflow better.

2. Always Branch First

Never let an agent work directly on main.

Start on a feature branch so the agent’s changes remain isolated and reversible.

3. Add Rules in a Context File

Here’s the real game-changer.

In a .goosehints or AGENTS.md file, include this line:

“Every time you make a change, make a commit with a clear message.”

This single rule transforms the entire collaboration:

It forces automatic checkpointing
It creates a perfect chronological trail of the agent’s decisions
It turns your git history into an instant undo system

No more manually hunting for hidden edits.

4. Work With Confidence

Once the rule is in place, let the agent build, refactor, or fix freely.

If it goes off track, all you need is:

git log to inspect its steps
A quick diff to review changes
Or simply: “Revert to commit abc123.”

Your workflow becomes transparent and reversible.

The Result

By applying one simple habit — frequent commits — you eliminate anxiety from AI-assisted development. The agent remains helpful, but you stay in control.

No more digging through seventy files for a rogue change
No more hoping the agent “remembers” what it did
No more surprise edits hiding in your repo

Just clean commits, clear history, and total confidence.

Try goose on your next project.

Your future self (and your git history) will thank you.

(Thumbnail credit: https://petesena.medium.com/?source=post_page---byline--124b9288e551---------------------------------------)

Mashraf Aiman
CTO Zuttle
AGS NIRAPAD Alliance

Little biography of a CTO

Mashraf Aiman — Thu, 11 Dec 2025 10:01:24 +0000

Huge Thanks to Walisa Afra for writing such an amazing Biography