r/GPT3

Sam Altman just made the biggest infrastructure bet in AI history.

OpenAI is spending over $20 billion on a new type of computer chip specifically designed to make ChatGPT faster, smarter and more responsive than ever.

These aren’t regular chips. Cerebras builds wafer-scale processors (the largest chips ever manufactured) that pack the processing power of an entire server rack onto a single piece of silicon the size of a dinner plate.

The goal is simple. Make ChatGPT respond in real time with zero lag. Enable AI agents that can think and act for minutes or hours without stopping. Process your requests faster than you can type them.

OpenAI is also taking an equity stake in Cerebras, meaning the company behind ChatGPT now partially owns the company building the hardware powering it.

For context, $20 billion is more than most countries spend on their entire technology infrastructure in a year.

OpenAI already surpassed $25 billion in annual revenue. They are now spending most of it on getting faster.

900 million people use ChatGPT every week. Every single one of them is about to notice the difference.

Claude has had a rough week. Between the outage and the usage limit threads, I figured it was actually good timing to do something I had been meaning to try anyway: take the D&D skill I built a few weeks ago and see if I could migrate it to run on OpenCode with free or local models. If Claude is your DM and Claude goes down mid-session, that is a problem worth solving.

The short version: it works, and it was easier to set up than I expected.

What I built

open-tabletop-gm is a fork of the original claude-dnd-skill, rebuilt to run on any LLM through OpenCode. OpenCode supports Anthropic, OpenAI, Google, Ollama, LM Studio, and any OpenAI-compatible endpoint, so you can point it at whatever is available. Free tier models, local models, a different provider entirely.

The Claude-specific parts (model routing between Haiku/Sonnet/Opus, the ~/.claude/ path structure, autorun) have been replaced with portable equivalents. The campaign files, display companion, and Python toolchain are all identical.

While I was at it, I also pulled D&D 5e out of the core and turned it into a system module. The GM core (pacing, NPC craft, improvisation, consequences) lives in one file and knows nothing about any specific game. D&D 5e lives in a separate systems/dnd5e/ folder. If you want to run Vampire: The Masquerade, Cyberpunk RED, Pathfinder, or any other TTRPG, you write a system.md describing your game's dice resolution, stats, health model, and conditions - and the same GM core runs it. There is a porting guide covering what transfers directly from the D&D implementation vs what needs configuring per game. D&D 5e is the reference implementation and ships fully built out. Everything else is a system.md away.

Why smaller/free models hold up better than you might expect

The Python toolchain carries a lot of the weight that would otherwise fall on the model:

• Dice rolls, HP math, damage tracking: Python
• Initiative and turn order: Python, tracked in a live sidebar
• Timed effects and conditions: Python, file-persisted
• SRD data lookup (spells, monsters, items): local JSON

The model's job is narration and judgment. It reads the campaign state from plain Markdown files and narrates from there. It does not do arithmetic and does not need to hold mechanical state in memory. That separation is what makes free and smaller models viable: the parts that tend to break on constrained models have been moved out of the model entirely.

First test: MiniMax M2.5 via OpenCode

Tested against the original claude-dnd-skill version. Setup was surprisingly frictionless -- OpenCode picked up the skill file without extra configuration. The model produced creative NPC responses and correctly read deceptive intent in a player message. More than I expected from a first pass on a free tier model.

Current testing: Qwen3-32B via LM Studio

Working well on the portable version so far. Script calls reliable, narration solid, campaign state persisting correctly across sessions. Testing is being pushed down toward Qwen3-14B to find the practical floor. Results going into the LLM guide as they come in.

What stays the same

Everything you already know from the original skill: persistent campaigns, the cinematic display companion you can Chromecast to a TV, character sheets, the DM philosophy, NPC memory, all of it. The system module architecture now lets you run any TTRPG, not just D&D 5e, by writing a system.md for your game. But if you are running D&D the experience is the same.

Claude is still the better DM

To be clear: this is not a "switch away from Claude" post. Claude Code with claude-dnd-skill is still the better experience. Better narration, model routing, deeper integration. If Claude is up and you have quota, use that.

But having a version that works when it is not is genuinely useful. And honestly, testing it has been a good reminder of how much the Python toolchain is doing independent of any specific model.

Links

• Repo: https://github.com/Bobby-Gray/open-tabletop-gm
• LLM guide (WIP): https://github.com/Bobby-Gray/open-tabletop-gm/blob/main/docs/LLM-GUIDE.md
• Original skill (Claude Code): https://github.com/Bobby-Gray/claude-dnd-skill

The contrast is actually depressing.

We used to have Elon Musk pushing for Mars and Demis Hassabis (DeepMind) solving protein folding to cure diseases.

That was "humanity-shifting" energy.

Now, Altman and Amodei have turned AI into a mid-wit hype cycle of:

• Meaningless benchmarks
• Model vs. model ego trips
• Weekly "revolutionary" updates that do nothing

We went from "colonize planets" to "did we beat GPT by 2%?"

Look at the OpenAI founding team—literally every single one left because the "Open" part became a corporate lie.

Anthropic claims to care about "safety," yet their talent is already jumping ship.

These guys care more about winning a race than why we're running it. We traded real innovation for a subscription-based dead end.

I do a lot of long research sessions in ChatGPT, sometimes 40–60+ messages deep. The problem was always retrieval: useful answers and code snippets got buried, and finding them meant endlessly scrolling back through everything.

So I built a simple highlight system into my Chrome extension.

How it works:
You select any text and press Ctrl+Shift+H. It gets highlighted, saved, and stays there even after refreshes or restarts. There’s also a small navigation bar at the bottom with Previous / Next and a counter, so you can jump between highlights instantly.

Why this is better than just copying things:
Highlights stay in context, so you can still see the surrounding conversation instead of losing where it came from. You can keep working without breaking your flow to copy things out. Then at the end, you can just review everything you marked.

Where I actually use it:

• Marking action items during planning conversations
• Flagging useful code snippets while debugging without losing the thread
• Highlighting the best outputs during brainstorming so I end up with a clear shortlist

It’s free and works on ChatGPT, Claude, and Grok:
https://www.getaiworkspace.com/chatgpt-text-highlighter

Been using ChatGPT daily for work (developer here), and there's one thing that's been driving me absolutely crazy for months: the lag.

You know the drill - you start a fresh conversation, responses come in lightning fast. But after 20-30 exchanges? Every. Single. Response. Takes. Forever. That spinning circle becomes your new best friend. Sometimes I'd wait 15-20 seconds just to see the first token appear.

I tried everything:

• Starting new chats constantly (losing context sucks)
• Manually deleting older messages (tedious af)
• Using the "continue in new chat" workaround (breaks the flow)
• Just... waiting (not great when you're on a deadline)

The thing is, I usually only need the last few exchanges for context anyway. The AI doesn't need my debugging session from 50 messages ago to help me with my current question.

So I finally got fed up enough to actually do something about it. I built an auto-trim feature into a Chrome extension I've been working on. Dead simple concept:

• Toggle it on
• Set how many recent messages you want to keep visible (I use 10-15)
• Older messages get hidden from the DOM
• ChatGPT thinks the conversation is short → responds fast again

The difference is night and day. Went from waiting 10+ seconds to near-instant responses, even in conversations with 100+ messages.

The technical bit (for those curious): ChatGPT's frontend seems to process/render the entire conversation history when generating responses. By trimming what's visible in the DOM, you're essentially giving it less to chew on. Your full history is still there, just hidden. Toggle it off and everything comes back.

Honestly thought I was going crazy thinking the length affected speed until I tested it systematically. Turns out it's a pretty well-known issue but I hadn't seen anyone automate a solution for it.

Anyone else been dealing with this? Curious if this is primarily a browser/frontend thing or if it also affects API users.

Edit: Since a few people asked - yes it's part of a free extension I made called AI Workspace. Didn't want to make this a promo post, just genuinely excited that this actually works lol. https://www.getaiworkspace.com/