DEV Community: Max Polaczuk

Stop Benchmarking AI Coding Agents on Todo Apps. Make Them Build an MMO.

Max Polaczuk — Tue, 23 Jun 2026 01:17:56 +0000

A coding agent that can scaffold a todo app is no longer interesting.

Give it an MMO.

An online world is not one feature. It is a collision between real-time networking, persistent state, combat math, character progression, inventories, economies, social systems, content, deployment, security, and a client that must remain responsive while the server remains in control.

Every subsystem can break every other subsystem.

That is why an MMO is such a useful stress test for AI-assisted software development—and why we decided to try building one in a weekend.

The result was World of ClaudeCraft, a free and open-source browser MMO.

Not a trailer. Not a generated screenshot. Not a single-room demo with one enemy.

A live, persistent world you can enter from a browser.

What the weekend produced—and what came next

A 48-hour experiment with Anthropic's Claude Fable 5 produced the playable foundation. It has since grown into a playable level 1–20 world with nine classes, three open zones, nearly 90 quests, instanced dungeons, boss mechanics, parties, trading, duels, ranked PvP, persistent characters, offline play, mobile controls, and 14 locales.

The independent MMO publication MMORPG.com called it “surprisingly complete” and noted that it had played studio demos in rougher condition despite far longer development cycles.

That outside reaction matters. But it is not the most interesting part.

The most interesting part is that you can inspect the code.

levy-street / world-of-claudecraft

World of ClaudeCraft

Quest, group up, and raid a hand-built world, free in your browser. Open source, web3, and online right now.

English · Español · Español (España) · Français · Français (Canada) · Italiano · Deutsch · 简体中文 · 繁體中文 · 한국어 · 日本語 · Português (Brasil) · Русский

Play now · Host your own world · Train an agent · Web3 · Contributing · Discord

What this is

World of ClaudeCraft is a complete classic-era MMO you can play right now in your browser, host yourself with one command, and even train AI agents to play. It is free, open source, and live at worldofclaudecraft.com.

One shared world runs in three places, all from the same game core:

the offline browser world, where you click Play Offline and you are in,
the authoritative multiplayer server, where Postgres-backed accounts share a live world,
the headless RL…

View on GitHub

The repository is MIT-licensed. You can run the game locally, host your own persistent world, train an agent against the real simulation, or fork the project and change its rules.

That makes World of ClaudeCraft more than an AI demo. It makes it a falsifiable engineering artifact.

The architecture is the real story

The project is held together by one rule:

There is one deterministic game simulation, and every host uses it.

                         ┌─────────────────────────────┐
                         │  Deterministic TypeScript   │
                         │     simulation: src/sim     │
                         └──────────┬───────┬──────────┘
                                    │       │
                      ┌─────────────┘       └─────────────┐
                      │                                   │
              Offline browser                    Authoritative server
              instant local world                REST + WebSocket + Postgres
                      │                                   │
                      └──────────────┐       ┌────────────┘
                                     │       │
                                  Headless RL host
                                  Python + Gymnasium

The offline browser world, multiplayer server, and reinforcement-learning environment do not contain three reimplementations of the game. They host the same core.

The renderer and HUD talk to an IWorld interface rather than a concrete implementation. Offline, the local simulation satisfies that interface. Online, a client-side mirror consumes server snapshots. In both cases, the presentation layer sees a world—not the machinery behind it.

Meanwhile, the multiplayer server is authoritative. Clients send movement intent and commands. The server resolves combat rolls, loot, quest credit, trades, vendor transactions, and progression. PostgreSQL persists the character state. The browser renders the result.

That separation is not glamorous, but it is why the prototype could keep growing without becoming code confetti.

AI output is cheap. Architectural invariants are valuable.

Determinism became a force multiplier

The simulation does not depend on wall-clock time or Math.random(). Seed the environment, replay the actions, and you can reproduce the episode.

That single constraint creates several advantages:

Offline and online combat can follow the same rules.
Tests can reproduce failures instead of chasing intermittent state.
A headless agent can train against the actual game rather than a simplified port.
Automated parties can clear dungeons and expose regressions across combat, threat, healing, loot, and encounter scripting.
Cosmetic systems can remain outside the simulation. Even biome weather is render-only, so rain cannot accidentally change game state.

This is the kind of detail that gets lost when people evaluate AI coding by counting generated lines.

The better question is: did the system become easier to verify?

Procedural generation was a scope strategy, not a gimmick

A weekend MMO cannot wait for a conventional asset pipeline.

Much of World of ClaudeCraft's scenery, terrain, weather, spell iconography, animation, and sound is generated at runtime. The project also uses credited, freely licensed assets where appropriate.

That choice reduced coordination costs and kept iteration close to the code. A developer could change a biome, creature family, icon system, or sound generator without waiting for a separate production queue.

It also produced an unexpected benefit: contributors can change more of the world through code.

Procedural generation did not remove art direction. It compressed the distance between an idea and a testable result.

A serious coding benchmark needs cross-cutting consequences

A todo app usually rewards local correctness. Add a field, update a form, change a schema, pass a test.

An MMO punishes local thinking.

Add one class ability and you may need to touch:

simulation rules,
resource costs and cooldowns,
targeting and range validation,
server command handling,
client presentation and feedback,
action bars and tooltips,
persistence,
localization,
bots and automated tests,
PvE and PvP balance.

This is where long-horizon coding agents become interesting. The challenge is not producing ten files. The challenge is preserving a coherent model across ten files while the product is changing underneath them.

World of ClaudeCraft suggests a more useful way to measure AI-assisted development:

Do not ask how much code the model wrote. Ask how many consequential decisions the human team could validate per hour.

Good harnesses, deterministic state, explicit interfaces, fast tests, browser automation, and server authority make that number go up. Prompt cleverness alone does not.

What the AI did—and what it did not do

Claude accelerated implementation dramatically. It helped turn a deliberately unreasonable scope into a playable foundation over one weekend.

That does not mean “one prompt replaced a game studio.”

The model did not decide why the world should exist. It did not define acceptable game feel. It did not own the architectural invariants, choose what to cut, judge whether combat was fun, operate the live service, review community contributions, or decide what deserved to ship.

Human direction stayed in the loop because software is not valuable merely when it compiles. It is valuable when someone can explain its constraints, test its behavior, and take responsibility for the result.

The practical lesson is less dramatic—and more useful:

Small teams can now attempt systems that were previously irrational for them to attempt.

The most important feature arrived after launch

After the first version went public, people did not only play it. They opened issues, submitted pull requests, forked the repository, translated text, fixed bugs, and built new systems.

The GitHub project quickly passed 1,000 stars and 300 forks. The game continued growing from its weekend foundation into a larger world with more quests, multiplayer systems, dungeons, PvP, and raid content.

The model that seeded the project was publicly available for only three days before access was suspended. The world it helped create kept moving.

That may be the more durable pattern:

AI compresses the cost of the first playable system. Open source and human community determine whether it becomes a living one.

Run it before arguing about it

You can play World of ClaudeCraft in your browser with no download, or run your own world from the source:

git clone https://github.com/levy-street/world-of-claudecraft.git
cd world-of-claudecraft
cp .env.example .env

# Set a strong POSTGRES_PASSWORD in .env, then:
docker compose up -d --build

# Open http://localhost:8787

Then inspect src/sim/. Break an invariant. Add an ability. Train an agent. Build a boss mechanic. Open a pull request.

The next useful AI coding benchmark should not be another landing page.

It should be a system with enough moving parts to fight back.

What would you add to make this benchmark harder?

How We Deliver Production-Ready Websites in 24 Hours: A Technical Deep-Dive

Max Polaczuk — Sat, 14 Jun 2025 01:22:41 +0000

Building websites fast isn't about cutting corners — it's about smart automation, battle-tested workflows, and the right tech stack. Here's how our team at Mogged delivers premium websites to New Zealand businesses in just 24 hours.

The Challenge: Speed Without Sacrificing Quality

When I started building websites for local Wellington businesses, the same pattern kept emerging: small business owners needed professional websites yesterday, but traditional agencies quoted 4-8 week timelines.
The market gap was obvious. But could we actually deliver quality websites in 24 hours?
Spoiler: Yes, but it required rethinking everything about web development.

Our Tech Stack: Built for Speed

Here's the exact stack we use to achieve 24-hour delivery:

const techStack = {
  framework: 'Next.js 14',
  styling: 'Tailwind CSS + Custom Design System',
  deployment: 'Vercel Edge Network',
  cms: 'Sanity.io (headless)',
  forms: 'Custom API + Discord Webhooks',
  analytics: 'Google Analytics 4 + Custom Events',
  monitoring: 'Sentry + Uptime Robot'
};

Why This Stack?

Next.js 14: App router, server components, and built-in optimization
Tailwind CSS: Rapid styling with our pre-built component library
Vercel: Push-to-deploy with automatic SSL and global CDN
Sanity: Real-time collaboration and instant content updates

The 24-Hour Process: Technical Breakdown
Hour 0-2: Discovery & Setup Automation

# Our project initialization script
npx create-mogged-site \
  --client="XYZ Plumbing" \
  --type="tradie" \
  --features="booking,gallery,contact" \
  --deploy="production"

This custom CLI tool:

Scaffolds the entire project structure
Configures environment variables
Sets up Git repository
Initializes Sanity studio
Deploys preview environment

Hour 2-8: Parallel Development

Here's where the magic happens. We run three parallel workstreams:

// Design tokens are programmatically generated
const generateDesignSystem = (brandColors, businessType) => {
  return {
    colors: {
      primary: brandColors.primary || '#4361ee',
      secondary: calculateComplementary(brandColors.primary),
      ...generateColorScale(brandColors)
    },
    typography: getIndustryTypography(businessType),
    spacing: baseSpacingSystem,
    components: loadComponentPresets(businessType)
  };
};

Stream 1: Design System Generation

AI-assisted color palette generation
Industry-specific typography selection
Component preset loading

Stream 2: Content Structure

// Sanity schema generation based on business type
export const generateSchema = (businessType: BusinessType) => {
  const baseSchema = getBaseSchema();
  const industryFields = getIndustrySpecificFields(businessType);

  return mergeSchemas(baseSchema, industryFields);
};

Stream 3: Development

Component assembly using our library
API integrations (Google Maps, booking systems)
Performance optimization

Hour 8-18: The Build Phase
This is where our component library shines. We've built 50+ pre-optimized components:

// Example: Our optimized Hero component
export const Hero = ({ data, variant = 'default' }) => {
  return (
    <section className={cn(
      'relative min-h-screen flex items-center',
      variants[variant]
    )}>
      <OptimizedVideo 
        src={data.video}
        poster={data.poster}
        loading="eager"
        priority
      />
      <div className="container relative z-10">
        <AnimatedText 
          text={data.headline}
          className="text-5xl md:text-7xl font-bold"
        />
        <CTAButton href={data.ctaLink} tracking={data.tracking}>
          {data.ctaText}
        </CTAButton>
      </div>
    </section>
  );
};

Hour 18-22: Optimization & Testing
Our automated testing suite ensures quality:

// Automated performance testing
const performanceTests = async (siteUrl) => {
  const results = await runLighthouse(siteUrl, {
    onlyCategories: ['performance', 'accessibility', 'seo'],
  });

  if (results.performance < 90) {
    await optimizeAssets(siteUrl);
    await enableLazyLoading();
    await implementCriticalCSS();
  }

  return results;
};

Hour 22-24: Deployment & Handover

# Final deployment checklist
- [ ] SSL certificate active
- [ ] DNS propagation complete
- [ ] Analytics tracking verified
- [ ] Form submissions tested
- [ ] Mobile responsiveness checked
- [ ] Page speed > 90
- [ ] SEO meta tags populated
- [ ] Backup system enabled

Key Innovations That Make This Possible

1. Component-First Architecture
We've built a comprehensive library of New Zealand business-focused components:

// Industry-specific component example
<TradieTrustSignals 
  certifications={['Master Builders', 'Site Safe']}
  guarantees={['Workmanship Guarantee', 'Fixed Price']}
  insurances={['Public Liability', 'Contract Works']}
/>

2. Smart Content Defaults

const contentDefaults = {
  tradie: {
    hero: 'Quality {service} in {location}',
    cta: 'Get Your Free Quote',
    trust: ['Licensed', 'Insured', 'Local'],
  },
  hospitality: {
    hero: 'Experience {cuisine} in the heart of {location}',
    cta: 'Book Your Table',
    trust: ['Fresh Daily', 'Locally Sourced', '5-Star Reviews'],
  }
};

3. Automated SEO Optimization

// Dynamic SEO generation
export const generateSEO = (business) => {
  return {
    title: `${business.name} | ${business.service} ${business.location}`,
    description: generateDescription(business),
    openGraph: generateOGTags(business),
    structuredData: generateLocalBusinessSchema(business),
  };
};

Lessons Learned

1. Constraints Drive Innovation
The 24-hour limit forced us to:

Build reusable systems
Automate repetitive tasks
Focus on what matters to small businesses

2. Local Context Matters
New Zealand businesses have unique needs:

Multi-location support (Auckland, Wellington, Christchurch)
Integration with local services (NZ Post, local payment providers)
Compliance with NZ privacy laws

3. Speed Is A Feature
Fast websites aren't just about development speed:

// Our performance budget
const performanceBudget = {
  fcp: 1.8, // First Contentful Paint
  lcp: 2.5, // Largest Contentful Paint  
  fid: 100, // First Input Delay
  cls: 0.1, // Cumulative Layout Shift
};

The Business Impact
Since implementing this system:

Delivered 100+ websites across New Zealand
Average client sees 2-3x increase in online inquiries
100% on-time delivery rate
5-star reviews across the board

Conclusion
Building websites in 24 hours isn't about working faster—it's about working smarter. By combining modern web technologies, automation, and a deep understanding of local business needs, we've created a system that delivers exceptional results.

Whether you're a developer looking to streamline your process or a business owner needing a website yesterday, the principles remain the same: automate the repetitive, focus on what matters, and never compromise on quality.

Are you a developer in New Zealand looking to build better websites faster? Or a business owner who needs a professional website without the wait? Check out Mogged - we deliver premium websites in 24 hours for Kiwi businesses.

Follow me for more web development insights and feel free to reach out if you want to discuss rapid development techniques!

webdev #webdesign #newzealand #automation #performance #smallbusiness

The Best New AI Image Generator

Max Polaczuk — Mon, 27 May 2024 22:14:51 +0000

I'm thrilled to share the AI Image Generator that we have been working hard on: Idyllic App!

In a market that's becoming increasingly saturated with AI tools, Idyllic App stands out with its unique approach to user experience and product design. Our AI image generator is designed with two main goals in mind: making it incredibly user-friendly for non-tech users and creating a seamless environment for exploring the stunning content generated by our vibrant community.

Why Idyllic App is the Best AI Art Generator

Streamlined for Non-Tech Users: One of the biggest challenges with many AI image generators is their complexity. At Idyllic App, we've invested significant effort into ensuring that even users with no technical background can easily create and explore AI art. The interface is intuitive, and the process is straightforward, making the world of AI-generated images accessible to everyone.

Seamless Community Exploration: Beyond just generating images, Idyllic App offers a unique experience where users can effortlessly explore the amazing AI art created by others. The app's recommendation system evolves in real-time, providing users with increasingly personalized content as they create and explore. This feature not only enhances user engagement but also rewards users with a richer experience simply by enjoying the app.

In other words, Idyllic App is equal parts AI art generator and AI image exploration tool. We believe that achieving this balance makes our app the best AI art generator available.

Create and Explore a Variety of AI Images

Idyllic App empowers you to create a wide range of AI-generated images, from humorous memes to breathtaking masterpieces. Whether you're looking to generate something funny or create a work of art, Idyllic App has you covered.

No Registration Required to Explore

One of the most user-friendly features of Idyllic App is that you don't need to register an account to search through and explore the stunning AI art generated by other users. This open access encourages more users to engage with the app and discover the possibilities of AI-generated art.

Impressive Growth and User Engagement

Since our launch three months ago, we've seen incredible growth and engagement:

40k Registered Accounts: Our user base is rapidly expanding, completely organically, showing the appeal and usability of Idyllic App.
12k Searches a Day: Users are actively exploring and engaging with the AI art on our platform daily.

Idyllic App is not just an AI image generator; it's a thriving community of creators and explorers. Join us today and discover the future of AI-generated art. Visit Idyllic App and start your journey into the world of AI art!