DAILY NEWS

Stay Ahead, Stay Informed – Every Day

Advertisement
TECH & AI
Google DeepMind Gets Into Gaming, Purchases Stake in the Company Behind EVE Online
jackminion 0



AI companies have long used video games to train and test their models, so it’s not a huge surprise that Google DeepMind has now acquired a minority stake in the maker of the popular MMORPG EVE Online. The partnership comes as the studio behind EVE Online announced that it is becoming independent again. Fernris Creations, formerly known as CCP Games, said that it has bought itself back from Korean video game company Pearl Abyss in a deal worth $120 million. EVE Online first launched in 2003 and is known for its sprawling open-world universe, where players can explore more than 7,000 star systems and participate in various in-game activities like mining, piracy, trading, combat, and even politics. 

Alongside the buyout announcement, the company also revealed a new research partnership with Google DeepMind, in which the AI lab has taken a minority stake in Fernris Creations. “As part of this next chapter, we are beginning a research partnership with Google DeepMind, focused on intelligence in complex, dynamic, player-driven systems. This is something I am genuinely excited about,” Fernris Creations CEO Hilmar Veigar Pétursson wrote in a blog post announcing the partnership.

According to a press release, the collaboration will focus on improving the “understanding of intelligence in complex, dynamic systems” and explore areas such as long-horizon planning, memory, and continual learning. In practice, Google DeepMind will test and evaluate AI models on an offline version of EVE Online running on a local server. The companies also said they plan to explore AI-powered gameplay experiences.

“I’ve known Hilmar for many years and long admired his work, and I’m thrilled to partner with him and the fantastic team at Fenris Creations to explore new gaming experiences and advance AI research safely inside a player-driven universe as amazingly complex as EVE Online,” Google DeepMind CEO and co-founder Demis Hassabis said in the press release. Hassabis added that video games are the “perfect training ground for developing and testing AI algorithms.” He pointed to some of the lab’s previous breakthroughs, including AlphaGo defeating world champion Lee Sedol in 2016 and AlphaStar reaching “Grandmaster” level in StarCraft II in 2019.

Other AI companies have pulled off similar feats. In 2019, an AI built by OpenAI defeated world champions in Defense of the Ancients 2, better known as Dota 2. OpenAI’s success with Dota 2 has even resurfaced this week during Elon Musk’s ongoing legal battle with OpenAI and CEO Sam Altman.  The New York Times reports that after OpenAI President Greg Brockman emailed Musk to inform him that the company’s AI had won an international Dota tournament, Musk replied: “Time to make the next step for OpenAI. This is the triggering event.”



Source link

TECH & AI
Stop Letting AI Write Your Database Migrations
jackminion 0



The era of “just ask the LLM” has made us remarkably productive, but it has also made us dangerously comfortable. We are currently witnessing a shift where developers are offloading critical infrastructure decisions to generative models. While having an AI suggest a React component or a regex pattern is relatively low-stakes, letting it dictate your database schema transitions is playing with fire.

The problem isn’t that AI is “bad” at SQL; it’s that AI lacks context. It doesn’t know your traffic patterns, it doesn’t understand your locking mechanisms, and it certainly doesn’t care if your production environment goes dark at 3:00 AM because of a table lock that lasted ten minutes too long.

The Illusion of “It Works”

When you ask an AI to generate a migration — say, adding a non-nullable column with a default value to a table with five million rows — the code it gives you will likely be syntactically perfect. You run it in your local environment with fifty rows of seed data, and it finishes in milliseconds.

The issue arises when that same script hits a production environment.

The Before (AI-Generated Standard):

–Generated by AI: Simple, clean, and potentially catastrophic
ALTER TABLE orders ADD COLUMN status_code VARCHAR(255) NOT NULL DEFAULT ‘pending’;

Enter fullscreen mode

Exit fullscreen mode

On a massive table, this operation can trigger a full table rewrite. In PostgreSQL, for instance, versions prior to 11 would lock the entire table while writing that default value to every single row. If your application is high-traffic, your API starts throwing 504 Gateway Timeouts because every connection is waiting for that lock to release.

The After (Human-Engineered Safe Migration):

— Step 1: Add the column as nullable first (instant operation)
ALTER TABLE orders ADD COLUMN status_code VARCHAR(255);

— Step 2: Set the default for future rows
ALTER TABLE orders ALTER COLUMN status_code SET DEFAULT ‘pending’;

— Step 3: Update existing rows in small batches to avoid long-held locks
— (This would typically be handled via a background job or scripted loop)

— Step 4: Add the NOT NULL constraint after data is populated
ALTER TABLE orders ALTER COLUMN status_code SET NOT NULL;

Enter fullscreen mode

Exit fullscreen mode

When “Convenience” Costs Millions

We don’t have to look far to see where automated or poorly planned migrations caused genuine wreckage. One of the most famous examples of migration-related downtime was the 2017 GitLab outage. While that was a human error during a manual intervention, it highlights the fragility of database state.

More recently, several tech startups have reported “silent” data corruption when AI-generated migrations suggested changing column types (like INT to BIGINT) without account for how the underlying ORM would handle the transition during a rolling deployment. If your AI-written migration drops a column before the new version of your application code is fully deployed across all nodes, your “After” state is a series of 500 errors.

The Context Gap

AI models operate on patterns, not performance profiles. They don’t know:

The Lock Hierarchy: Will this ALTER TABLE block SELECT queries?
Replication Lag: Will this massive update stall your read replicas?
Deployment Strategy: Is this a blue-green deployment or a rolling restart?

A migration is not just a script; it is a bridge between two states of a living system.

Moving Forward: Use AI as a Drafter, Not an Architect

I am not suggesting we go back to the Stone Age. AI is a phenomenal tool for boilerplate. If you need to scaffold a complex set of join tables, let the AI write the initial DDL.

But the moment that code touches a migration file, the “AI” portion of the task ends. You must take over as the engineer. You need to verify the locks, check the execution plan, and most importantly, simulate the migration against a production-sized data set.

If you’re interested in seeing how I’ve handled high-performance, SEO-optimized database architectures without relying on “magic” scripts, you can check out my project documentation on my GitHub or follow my updates on LinkedIn.

The database is the heart of your application. Don’t let a probabilistic model perform open-heart surgery on it.

You can find me across the web here:



Source link

TECH & AI
I built an MCP server so AI agents can flash 1,000+ embedded boards
jackminion 0


npx pio-mcp dashboard

Enter fullscreen mode

Exit fullscreen mode

That’s the install. Open a terminal anywhere — your laptop, a fresh VM, a coworker’s machine — type one line, and you get a React dashboard wired to PlatformIO Core. From there an LLM can compile firmware, flash it to a real board, and stream serial back to the same browser tab.

platformio-mcp v2.0.0 shipped to npm. Here’s why and how.

The gap

LLMs are stupidly good at writing firmware. Hand Claude a datasheet and it’ll spit out C++ that compiles. Hand it the FreeRTOS docs and it’ll wire up a queue without breaking a sweat.

The next step always falls apart.

“Great, now flash it to the ESP32 sitting on my desk.”

You get back a markdown wall of “first install pyenv, then bootstrap a venv, then pip install platformio, then check your USB-C cable supports data, then make sure the right udev rule is in place on Linux, then…” It’s a setup-doc generator. The agent has read every PlatformIO tutorial ever written. It still can’t push bytes to flash memory because it has no hands.

MCP is the hands. The agent calls a tool, the tool runs on your machine, the result comes back. PlatformIO Core is already a CLI that knows how to talk to ~1,000 boards across 30+ platforms (ESP32-S3, RP2040, STM32H7, nRF52840, ATmega328P, Teensy 4.1, SAMD21, ATtiny85, and so on). I exposed it through MCP. That’s the whole product.

What v2.0.0 actually does

Nine MCP tools. Each one is a thin wrapper around a pio subcommand:

list_boards → pio boards
init_project → pio project init
build_project → pio run (background mode + status polling)
upload_firmware → pio run –target upload (optional start_monitor)
list_devices → pio device list
serial_monitor → pio device monitor (non-blocking, streamed)
search_libraries → pio pkg search
install_library → pio pkg install
list_libraries → pio pkg list
get_dashboard_url → returns localhost URL with bound auth token

Enter fullscreen mode

Exit fullscreen mode

Plus init_project, the unsung hero. PlatformIO project scaffolding is the thing agents got wrong every single time before this — they’d hand-write a platformio.ini with three subtle bugs in the board_build section. The MCP tool just shells out to pio project init and the bugs vanish.

The demo that closes the deal

Real prompt, real ESP32, real flash:

> Initialize a new Arduino project for an ESP32 Dev Board in /tmp/esp32-blink.
Build it, flash it, and start the serial monitor.

Enter fullscreen mode

Exit fullscreen mode

The agent’s tool calls, in order:

list_boards { filter: “esp32” } → esp32dev
init_project { board: “esp32dev”, framework: “arduino”,
projectDir: “/tmp/esp32-blink” }
build_project { projectDir: “/tmp/esp32-blink” } → SUCCESS
upload_firmware { projectDir: “/tmp/esp32-blink”,
start_monitor: true } → flashed

Enter fullscreen mode

Exit fullscreen mode

End-to-end on a clean machine: ~90 seconds. Most of that is the PlatformIO toolchain pulling esptool and the Espressif SDK on first run. Subsequent flashes are sub-10s.

Install in one command

We make it easy to integrate PIO MCP into your choice of coding agent. v2.0.0 ships a one-shot installer:

npx platformio-mcp install –cline # Cline (VS Code extension or CLI)
npx platformio-mcp install –claude # Claude Desktop
npx platformio-mcp install –vscode # VS Code native MCP support
npx platformio-mcp install –antigravity # Google Antigravity

Enter fullscreen mode

Exit fullscreen mode

Each installer:

Resolves the host’s config path per OS. macOS goes to ~/Library/Application Support, Windows reads %APPDATA%, Linux falls back to ~/.config. There’s a 9-line appDataDir() helper that does the dispatch.
Reads the existing config if one’s already there.
If the JSON is corrupted, copies it to .bak before rewriting. I learned this the hard way.
Idempotently merges an mcpServers.platformio block. Re-running the installer is a no-op.
Prints the path it touched so you can grep for it later.

For any other MCP host, this is the manual config block:

{
“mcpServers”: {
“platformio”: {
“command”: “npx”,
“args”: (“-y”, “platformio-mcp”, “–open-dashboard-on-start”)
}
}
}

Enter fullscreen mode

Exit fullscreen mode

The dashboard

The dashboard is the part nobody asks for and everybody uses once they have it.

Reason: build output is the worst possible thing to feed back to an LLM. A clean pio run for an ESP32 project is 40+ kilobytes of toolchain noise — arm-none-eabi-gcc flags, linker incantations, every single .o file. Pour that into the agent’s context and you’ve spent a third of your token budget on text the agent doesn’t need.

So the MCP tools return short, structured summaries to the LLM. The full output streams over Socket.io to a React dashboard the human can watch:

A per-process random UUID is injected as PORTAL_AUTH_TOKEN at boot. Every HTTP request and every Socket.io connection requires it. The dashboard URL looks like http://localhost:8080?token= and that token isn’t in any config file or env var the LLM has access to. If you launch the dashboard, only you (and the agent that spawned it) can hit the API.

The auto-launch is gated behind –open-dashboard-on-start (or the PIO_MCP_OPEN_DASH_ON_START=true env var). Browser launch goes through the open package, so the same call works on macOS, Linux, and Windows. The previous version had a hardcoded exec(‘open …’) that only fired on macOS — patched in v2.0.0.

Things I’m proud of that nobody will notice

The tarball is 499 kB. 114 files. build/ + web/dist/ + scripts/installers/ + LICENSE + README. No node_modules, no tests, no web/src/. The minified UI bundle is 921 kB / 291 kB gzip on its own; everything else is rounding error.

prepublishOnly runs the full TypeScript build, the Vite UI build, and a smoke check that asserts build/index.js, web/dist/index.html, and scripts/installers/index.js exist before npm allows the publish to proceed. Hard to ship a broken artifact.
Workspace state is mediated through proper-lockfile. Two agent processes can’t race each other on the same project. If you’ve ever had two MCP servers fight over the same serial port, you know why this matters.
The pio-mcp alias package is 842 bytes. Three files: a 283-byte bin.js that does import(“platformio-mcp”), a package.json with one dependency, a README. Same binary, shorter to type.
The default npx platformio-mcp (no subcommand) still boots the MCP stdio server. Existing configs that point at build/index.js keep working unchanged. v2 is additive.

Get started in five seconds

# Open the dashboard right now. No clone, no build, no install.
npx pio-mcp dashboard

Enter fullscreen mode

Exit fullscreen mode

# Wire it into your AI agent of choice.
npx platformio-mcp install –cline
npx platformio-mcp install –claude
npx platformio-mcp install –vscode
npx platformio-mcp install –antigravity

Enter fullscreen mode

Exit fullscreen mode

Repo: github.com/jl-codes/platformio-mcpnpm: platformio-mcp · pio-mcpRelease notes: v2.0.0

I’m @forkbombETH on X. Issues and PRs welcome on GitHub. If you build something cool with this, lmk.

npx pio-mcp dashboard

Enter fullscreen mode

Exit fullscreen mode

A huge warm thank you to Matt Mcneill for being an amazing collaborator and pushing for the features that make v2 amazing!



Source link