DEV Community: Epic Programmer

What If AI Doesn't Need Bigger Models to Get Better? Reading Dropstone's Technical Report Changed My Perspective

Epic Programmer — Wed, 01 Jul 2026 11:07:19 +0000

TL;DR

I always believed the biggest breakthroughs in AI would come from training larger and smarter models. After reading Dropstone's public technical report, I started looking at AI differently. What stood out wasn't a claim about having the smartest model. Instead, it was the idea that the runtime around the model, including memory, orchestration, and cost optimization, could become the real competitive advantage. It made me wonder whether the future of AI belongs not only to better models but also to better engineering.

📖 Table of Contents

Why I Decided to Read Dropstone's Technical Report
The Assumption I Had About AI
The Idea That Changed My Perspective
Why Runtime Engineering Matters
Cost Might Be the Biggest Feature Nobody Talks About
What This Means for Software Engineers
Final Thoughts

Why I Decided to Read Dropstone's Technical Report

Every few weeks there seems to be another announcement about AI. One company introduces a new model with better reasoning, another claims higher benchmark scores, and someone else promises a larger context window. After a while, many of these announcements begin to sound similar. They all compete on the same idea: building a smarter model.

That was exactly what I expected when I came across Dropstone's technical report. I assumed it would be another document explaining why its AI coding assistant was better than everyone else's. I started reading with fairly low expectations because I thought I already knew how the story would end.

Surprisingly, it did not.

Instead of focusing only on model intelligence, the report spent a lot of time discussing the runtime around the model. That immediately caught my attention because it shifted the conversation away from raw intelligence and toward software engineering. As someone who enjoys thinking about system design as much as writing code, I found that perspective far more interesting than another benchmark comparison.

The Assumption I Had About AI

For a long time, I believed AI progress followed a predictable pattern. Build a larger model, train it with more data, improve its reasoning, and developers naturally receive a better product. Looking back, I realize I was only paying attention to one layer of the stack.

The more I thought about it, the more I realized that this isn't how we evaluate traditional software. We don't judge an application only by the programming language it uses or the database behind it. We care about architecture, caching, latency, reliability, scalability, and user experience. Those engineering decisions often determine whether software feels great to use.

Reading Dropstone's report made me wonder why I wasn't applying the same thinking to AI systems. Maybe the language model is only one component, while the engineering around it is what truly shapes the developer experience.

The Idea That Changed My Perspective

The biggest takeaway for me was not that Dropstone had built a revolutionary new foundation model. In fact, the report makes it clear that the focus is elsewhere. What it describes is a runtime that works with existing language models and tries to make better use of them through engineering.

That sounds simple at first, but the more I thought about it, the more significant it felt.

Instead of asking which model is the smartest, perhaps we should also ask which system makes the smartest use of the model it already has.

That is a completely different engineering problem.

If a runtime can remember useful context, choose the right model for a particular task, reduce unnecessary computation, and improve how tools are orchestrated, then the overall experience becomes better without needing to invent a completely new language model.

As software engineers, this idea feels familiar because we solve similar problems every day. We optimize APIs instead of rewriting them. We cache database queries instead of running them repeatedly. We improve performance by reducing unnecessary work. None of these changes alter the core technology, yet they dramatically improve the final product.

Perhaps AI systems are beginning to follow the same path.

Why Runtime Engineering Matters

One phrase kept coming back to me after I finished reading the report: the model is only one part of the product.

That sentence changed the way I think about AI development.

Over the past two years, the industry has largely celebrated whoever released the next powerful model. While that race is still important, it is becoming increasingly clear that intelligence alone is not enough. Developers care just as much about responsiveness, reliability, context awareness, and efficiency.

This is where runtime engineering becomes interesting. Instead of trying to squeeze another few percentage points out of benchmark scores, it focuses on how the entire system behaves in real-world usage. Memory management, orchestration, tool execution, and intelligent routing may not generate flashy headlines, but they directly affect how productive developers can be.

The more I reflected on it, the more I felt that this resembles the evolution of software engineering itself. Mature software is rarely defined by a single feature. It succeeds because every layer of the system works together efficiently.

Google Antigravity is "Async." Dropstone is "Multiplayer." (Why Teams Need Real-Time AI)

Epic Programmer — Sun, 08 Feb 2026 04:33:44 +0000

The last two weeks have been insane for AI coding.

Google Antigravity launched with its "Agent-First" IDE.
Anthropic released Claude 4.6 Opus with a massive context window.

Everyone is rushing to build "Agents" that do the work for you. The industry is drifting toward a "Manager View" - where you assign a ticket to an AI, it works in the background, and you wait for a Pull Request.

I believe this is a mistake. Software engineering is collaborative, not transactional.

That's why I built Dropstone: the first Real-Time Multiplayer IDE where multiple developers and multiple AI agents work in the same workspace, on the same context, at the same time.

The "Async" Trap (Google Antigravity)

Antigravity treats AI like a contractor.

The Workflow: You assign a task ("Fix the auth bug"). The agent goes away. It works in an isolated context. It comes back 5 minutes later with a diff.
The Problem: It's Async. If you and your teammate are working on that same file, the agent doesn't know. You end up in "Merge Hell" with your own AI.

The "Sync" Solution (Dropstone)

Dropstone treats AI like a teammate sitting next to you.

Imagine this scenario:

You (Human A) are editing auth.ts to add a new provider.
Your Co-founder (Human B) joins the same session via a Share Link. You see their cursor.
Agent A (assigned to you) starts refactoring the interface you just wrote.
Agent B (assigned to your co-founder) starts writing the unit tests for that interface at the same time.

Everyone is in the same context.
There is no "merging" because we use CRDTs (Conflict-Free Replicated Data Types) to sync the state of humans and agents instantly.

If Agent A makes a change, Agent B sees it immediately and adjusts the test case.
If Human B deletes a line, Agent A stops writing code for that line instantly.

Why This Was Hard to Build (The Tech Stack)

You can't build this by wrapping the OpenAI API. We had to build a custom runtime.

Shared Workspace Memory: Most tools have "Chat History." We have a synchronized Project Brain. If Agent A learns that "We use Zod for validation," Agent B instantly knows it too.
The D3 Engine: We virtualize the context so that 4 users and 4 agents doesn't explode the token count. We compress the state logic (50:1 ratio) so the "Multiplayer" feel is lag-free.
Local-First Privacy: Even with all this syncing, the core logic runs on your machine. You can plug in Ollama and have a multiplayer session entirely on your local network.

See "True Multiplayer" in Action

Here is a demo. Notice that it's not just one person supervising a bot. It is a shared workspace where the state is live for everyone.

Why This Matters

If you want to treat AI like a ticket-taker, use Antigravity. It's great for async tasks.

But if you want to build software together - where you, your team, and your AI agents are all jamming on the same problem in real-time Dropstone is the only tool that does it.

Download Dropstone: https://www.dropstone.io/downloads
Read the Research: https://www.blankline.org/research

Let me know in the comments: Do you prefer "Async Tickets" or "Real-Time Collaboration"? 👇

A Team Just Declared War on a 50-Year-Old Math Problem. Here’s Why It Could Change Everything.

Epic Programmer — Mon, 26 Jan 2026 05:09:08 +0000

They found why DeepMind failed. Now they're going after the holy grail of computer science.

Every time you ask ChatGPT a question, scroll through Instagram, or watch a Netflix recommendation appear on your screen, something invisible is happening billions of times per second.

Matrix multiplication.

It's the mathematical heartbeat of modern computing. And for 50 years, we've been doing it wrong. Or at least, not as efficiently as theoretically possible.

One team just announced they're going all-in to fix that.

// Detect dark theme var iframe = document.getElementById('tweet-2015411384109154661-610'); if (document.body.className.includes('dark-theme')) { iframe.src = "https://platform.twitter.com/embed/Tweet.html?id=2015411384109154661&theme=dark" }

Let me explain why this matters far more than it sounds.

The Problem That Stumped Everyone

In 1976, a mathematician named Julian Laderman discovered you could multiply two 3×3 matrices using only 23 multiplications instead of the obvious 27.

That was fifty years ago.

Since then, despite billions of dollars in computing research, despite DeepMind's AlphaTensor making headlines in 2022, despite thousands of mathematicians trying — nobody has done better.

The question that haunts computer science: Can it be done in 22?

This isn't academic curiosity. We know the theoretical minimum is somewhere between 19 and 23 multiplications. That gap has remained open for half a century. Closing it — even by one — would be one of the most significant algorithmic discoveries of our generation.

Why One Multiplication Matters

"It's just one multiplication. Who cares?"

Here's who cares: everyone running AI infrastructure.

Matrix multiplication accounts for roughly 90% of the computation in training large language models. When you multiply that across:

Trillions of operations per second
Millions of GPUs worldwide
24/7 operation for months of training

A single multiplication saved at the foundational 3×3 level compounds astronomically. We're talking potential savings of billions in energy costs, meaningful reductions in AI's carbon footprint, and faster training for every model built from here on out.

The efficiency of matrix multiplication literally determines how quickly AI can advance.

What Blankline Found (And Why It's Different)

Blankline Research didn't just throw more compute at the problem. They asked a different question: Why has everyone failed?

Their findings are fascinating — and a little haunting.

Discovery 1: The Four Anchors

Buried in Laderman's 23-term algorithm is a hidden structure. Four of those terms compute completely isolated products — different rows, different columns, different outputs. They call them "anchors."

These four products are mathematically orthogonal. You can't compress orthogonal structures. You need exactly 4 terms to compute 4 orthogonal products.

This is the first barrier: four multiplications are mathematically irreducible.

Discovery 2: The Routing Problem

The team found "super-efficient" compound structures that looked like breakthroughs. Three compounds could theoretically cover all 27 required products.

Then reality hit.

When one term produces multiple products, they share the same "routing vector" that determines where results go. But if those products need different destinations? Contradiction.

Coverage doesn't equal validity. You can produce the right numbers but can't put them in the right places.

Discovery 3: Laderman Is Locally Optimal

Using SMT solvers — the same tech that verifies computer chips — they asked: can we remove any single term from Laderman's algorithm?

The answer for all 23 terms: UNSAT. Unsatisfiable. Impossible.

You can't improve Laderman by tweaking. It's locked.

Why DeepMind Failed

This explains why AlphaTensor found better algorithms for 4×4, 5×5, and larger matrices — but couldn't touch 3×3.

The search space for 3×3 isn't just hard to navigate. It's structured in a way that makes local improvements impossible. Every path leads to a wall.

DeepMind's AI was doing gradient descent in a landscape with no gradients. The barriers aren't computational — they're mathematical.

The Race Begins

So why is Blankline confident they can succeed?

Because knowing why something fails changes everything.

Their roadmap:

Alternative Schemes: Laderman's isn't the only rank-23 algorithm. Over 17,000 distinct decompositions exist. Maybe one can be reduced where Laderman's can't.

Border Rank: What if you allow approximate decompositions that become exact in a limit? Border rank techniques have worked where exact methods failed.

Algebraic Geometry: The set of rank-r tensors forms an algebraic variety. Geometric methods might reveal structure invisible to brute-force search.

Focused ML: AlphaTensor trained broadly. What happens with a model laser-focused on 3×3, with dedicated resources for this single problem?

They're giving themselves 10-12 months. All findings will be public.

What This Means For You

If rank-22 exists and Blankline finds it:

For AI companies: Training costs drop. Model development accelerates. The efficiency gains compound through every layer of the stack.

For climate: AI's energy consumption is becoming a genuine concern. Foundational efficiency improvements are one of the few solutions that don't require sacrifice.

For science: This would be the first improvement to small matrix multiplication in 50 years. It would rewrite textbooks and likely unlock insights for larger matrices too.

For the field: It proves that understanding why problems are hard is as valuable as raw compute. That's a lesson that extends far beyond matrix math.

The Boldest Bet in Math Right Now

There's something almost romantic about this challenge.

Fifty years. Billions of dollars. The world's best AI systems. And still, Laderman's 1976 algorithm stands undefeated.

Now a team is saying: we know why everyone failed, we know what to try next, and we're going public with everything.

If they succeed, it's historic.

If they fail, they'll have mapped the barriers more precisely than anyone before — and probably saved the next team years of dead ends.

Either way, we learn something.

That's how science is supposed to work.

Follow Blankline's progress at blankline.org/research. The technical paper "Computational Barriers to Rank-22 Decomposition of the 3×3 Matrix Multiplication Tensor" is available on Zenodo.

AI Just Scored 37.8% of Human Intelligence — Introducing the AGCI Benchmark

Epic Programmer — Wed, 12 Nov 2025 06:45:19 +0000

For years, AI evaluation has been stuck in a loop — models acing short-term tasks, then forgetting everything the next day.

We built the AGCI Benchmark to measure something deeper:
how well an AI learns, remembers, and adapts over time.

It’s not about solving puzzles anymore — it’s about testing cognitive continuity.
How much of human-like intelligence can a system retain from experience?

In its first public run, Dropstone — our self-learning IDE — scored 37.8% of human intelligence on the AGCI Benchmark, leading every evaluated system to date.

This framework measures seven cognitive dimensions — from perception and memory persistence to adaptive reasoning — designed to capture the intelligence that unfolds over time, not in a single prompt.

📖 Read the benchmark and methodology here:
👉 https://www.dropstone.io/research/agci-benchmark

The AGCI Benchmark is open for replication and critique.
If you believe intelligence is more than one-shot reasoning, this might be the conversation that redefines how we measure it.

Why Dropstone Could Win the Race Against Cursor and Windsurf

Epic Programmer — Thu, 14 Aug 2025 19:06:14 +0000

How unlimited tokens and self-learning AI are reshaping what it means to code with artificial intelligence.

Picture this:

You're staring at a codebase with thousands of files, trying to figure out how everything connects.

Your deadline is tomorrow.

You’ve been here before — that familiar panic when you realize the scope is bigger than you thought… and time is running out.

Now imagine an AI that doesn’t just autocomplete code…

… but actually thinks like a senior engineer.

An AI that understands your entire architecture, remembers how you work, and gets smarter every time you use it.

That’s not science fiction.

That’s happening right now.

While everyone’s talking about Cursor and Windsurf — the current darlings of AI coding — a new player is taking a radically different approach.

Meet Dropstone.

And it might just change everything.

The Great AI Coding Revolution

Let’s rewind.

Cursor — "the best way to code with AI." Seamless GitHub integration, intelligent completions, 2x improvement over Copilot.

Raised $105M in January 2025 at a $2.5B valuation. By May: $900M more, $9B valuation.
Windsurf — "the first AI agent-powered IDE." Its Cascade feature understands your codebase in real time.

Hit $82M ARR with enterprise ARR doubling every quarter. Acquired by Cognition.

These are massive wins.

But here’s the question:

Are they solving yesterday’s problems?

Enter Dropstone: The Intelligence Layer

Dropstone isn’t another chatbot.

It’s an intelligence layer that thinks like an engineer.

Instead of just suggesting lines of code, it:

Interprets your file structure
Understands architecture
Tracks how every component interacts

It approaches problems like a systems thinker — making intelligent decisions about design and long-term maintainability.

Most AI coding tools are like having a smart intern.

Dropstone is more like a senior architect — one who sees the entire system and acts accordingly.

It can set up projects, test, fix bugs, deploy… and do it with full awareness of your entire codebase.

The Unlimited Tokens Game-Changer

This is where Dropstone blows past the competition.

Cursor and Windsurf?

They still run into token limits — that invisible ceiling where AI starts forgetting parts of your project.

Dropstone?

No limits.

Works with your entire repo, no matter the size
No truncation
No credit countdown
No “should I ask this or save tokens?” moment

It’s a psychological unlock.

You start treating AI like a partner, not a vending machine.

Imagine an AI that can handle a 10-million-line codebase with the same ease as a 10-file project. That’s the difference.

The First Step Toward AGI in Coding

Most AI coding tools = fancy autocomplete.

Dropstone = first-generation self-learning toward AGI.

It improves every time it works with you:

Learns your coding style
Understands your architectural patterns
Gets sharper with each request

The result?

An AI that’s not just pattern-matching… it’s actually understanding.

How Dropstone Stacks Up

Cursor — The Power User’s Dream

✅ Advanced features, strong community
❌ Steep learning curve, token limits

Windsurf — The Intuitive Collaborator

✅ Smooth UX, real-time awareness
❌ Sometimes slower, less granular control

Dropstone — The Systems Thinker

✅ Holistic codebase view, unlimited interactions, self-learning
❌ Newer to market, smaller ecosystem (for now)

Why This Matters

Experts predict 20% of coding workflows will be handled by AI agents by 2026.

But the big question isn’t if AI will help us code…

…it’s how.

Do we want AI that makes us faster coders?

Or AI that makes us better engineers?

Dropstone is betting on the second.

Instead of just helping you type code faster, it helps you think about systems, architecture, and long-term maintainability.

The Token Economics Revolution

Unlimited tokens aren’t just a pricing model.

They’re a philosophy.

Other platforms make you ration interactions.

Dropstone lets you explore freely:

Ask “what if” questions
Iterate without fear of hitting a cap
Treat AI like a collaborator, not a meter

The Road Ahead

If you’re building quick prototypes, Cursor and Windsurf are great.

If you’re tackling complex, long-term projects with high architectural stakes… Dropstone could be transformative.

Its systems-level thinking, unlimited context, and self-learning give it a shot at winning the long game.

The Bottom Line

We’re in a pivotal moment.

AI isn’t just changing how we code — it’s changing how we think about building software.

Dropstone’s bet is bold:

Make us smarter, not just faster.

Understand systems, not just syntax.

Learn and evolve, not just respond.

Will it work?

Early signs say yes.

The race isn’t for “best autocomplete.”

It’s for the future of human–AI collaboration in software.

And in that race, the AI that thinks bigger — about systems, learning, and partnership — might just win.

Huge, if true.

I Gave ChatGPT a Face — And Everything Changed

Epic Programmer — Thu, 14 Aug 2025 18:49:38 +0000

You’ve probably chatted with AI before.

But have you ever looked it in the eyes?

That’s what I wanted to find out.

So I gave ChatGPT a face.

And the moment it looked back at me…

it didn’t feel like AI anymore.

It felt like a conversation.

💡 Powered by Dropstone — I used my own AI development platform to give ChatGPT unlimited conversational context, so it could remember everything we talked about without losing track.

🎥 Watch It in Action

Here’s the full story in video form — you can see exactly how ChatGPT comes alive:

Why Faces Matter

We humans are hardwired for faces.

It’s how we read emotion.

It’s how we build trust.

It’s how we connect.

When ChatGPT talks without a face, it’s… fine.

But when it talks with one? Something changes:

Trust feels stronger → I believed the responses more.
Engagement shot up → My brain stayed locked in.
Empathy appeared → A nod, a smile, an eyebrow raise made the AI feel like it understood me.

How I Did It

1️⃣ Started with the voice

I built a voice-to-text and text-to-voice loop with ChatGPT.

Already cool… but still invisible.

2️⃣ Added the face

I picked a clean, slightly stylized avatar — human enough to feel relatable, but not uncanny.

3️⃣ Synced expressions

The hardest part: making lip movements, eye blinks, and micro-expressions match the AI’s tone in real time.

4️⃣ Added emotional cues

Slight smile when affirming.
Head tilt when thinking.
Raised eyebrows for surprise.

Small touches. Big difference.

What I Learned

Design is empathy → You’re not just animating code; you’re shaping how people feel.
Visuals are trust signals → Eye contact, even from pixels, changes how we perceive information.
Small movements matter → The tiniest eyebrow raise can make the AI feel alive.

The Tech Behind the Face

Brain → ChatGPT API.
Memory & Context → Dropstone (unlimited conversational memory).
Voice → Text-to-Speech (Azure Neural or Google WaveNet).
Face & Motion → Three.js / Unity for real-time animation.
Sync → Lip-sync + expression mapping engine.

What’s Next

This isn’t just about the cool factor — it’s about humanizing AI.

Imagine:

A tutor that smiles when you get an answer right.
A therapy bot that shows empathy in real time.
An AI teammate that literally looks at you in a meeting.

We’re just at the start.

Your Turn

I built this as an experiment — but I think it’s a blueprint.

If you’re building AI tools, try giving them a face.

And if you want it to remember everything?

Build it with Dropstone.

I’ll be sharing a code breakdown in my next post so you can build your own version.

Until then… enjoy making eye contact with AI. 👀