How Much of Odd$mith Was Actually Built by AI?

When I first wrote about building Odd$mith with OpenClaw, the project was still early enough to describe as an experiment: could an AI agent work as a real collaborator inside a live product instead of just generating isolated code snippets?

Since then, Odd$mith has grown into something much bigger. It’s no longer just a prototype sports betting site with a few helpful workflows layered on top. It’s become a real editorial and product system with public content, premium features, staff tooling, async jobs, automated publishing lanes, and a production deployment split between a VPS and a Raspberry Pi development/workshop environment.

That naturally raises the question people usually want answered more directly:

So how much of Odd$mith was actually built by AI?

A lot.

Probably more than most people would believe if they’re picturing AI as “a smarter autocomplete” or “a chatbot that writes starter code.” But the honest answer is not “AI built the whole thing by itself.” The honest answer is that OpenClaw became a persistent implementation partner inside the project, and that changed what was possible.

The difference wasn’t just that it could write code. The difference was that it could stay inside the actual workspace, inspect the existing app, update real files, run commands, debug issues, help deploy changes, and keep iterating across many sessions without every prompt resetting back to zero.

That let Odd$mith evolve much faster than it would have if every feature, fix, and refactor had to start from a blank conversation.

What Odd$mith turned into after the original post

The first version of the story was about building a sports betting platform with OpenClaw. The current version is about what happened after that first build wave, once the project kept growing.

Odd$mith now includes:

• public betting/editorial content
• premium features and subscriber gating
• generated predictions and analysis pages
• blog and league news workflows
• recap generation
• Ask Odd$mith question-answering
• premium tools like live odds and arbitrage workflows
• operator-facing dashboard tooling
• async jobs for imports, grading, refreshes, and publishing
• production hosting on a VPS, with the Pi still acting as the development and workshop environment

That wasn’t one big launch. It was the result of a long chain of small, practical iterations: fixing bad UI, improving deploys, tightening content quality, breaking overloaded pages into cleaner staff tools, and gradually turning disconnected features into a more coherent system.

What’s automated now

A lot of the interesting progress in Odd$mith isn’t just “new pages exist.” It’s that more of the repetitive product machinery now runs through actual workflows.

Editorial and content automation

Odd$mith now has automated or semi-automated lanes for:

• generated prediction writing
• best-bet article/promo generation
• blog generation
• league news refreshes
• recap generation
• Ask Odd$mith responses
• source gathering and facts-first editorial support

That doesn’t mean fully unsupervised publishing everywhere. In practice, the system has been moving toward more automation in the parts that are repetitive and rules-driven, while still keeping human control over what deserves approval, editing, or public release.

Distribution and media automation

The automation layer also expanded into follow-through and media:

• social draft generation
• reel generation
• YouTube support
• auto follow-through paths for published content
• newsletter and premium messaging flows

Again, the important part isn’t that AI can spit out text for social posts. The important part is that it can participate in the operational chain around the content: creating drafts, helping move assets around, connecting the article layer to the media layer, and fitting into actual publish workflows.

Betting and premium product automation

Odd$mith also became much more than a content site. It grew into a product with actual betting-tooling lanes:

• live odds board
• arbitrage tools and calculations
• public calculators
• premium preview flows
• premium-only features and gating
• personalized-pick lanes
• separate pregame and live pick experiences

That kind of work isn’t glamorous, but it matters. A real product becomes useful because the content, pricing, UX, premium story, and operator tooling all start reinforcing each other.

Operations and staff automation

Some of the most valuable AI-assisted work was the boring internal stuff:

• daily imports
• grading workflows
• closing line capture
• import diagnostics
• dashboard/operator tools
• workflow visibility
• deploy and reload troubleshooting
• production migration support

That kind of work is easy to underestimate because it doesn’t always create a shiny new public feature. But it’s often the difference between “prototype” and “real operating system for the product.”

What AI actually handled well

The biggest misconception about AI-assisted software work is that people imagine it either doing nothing useful or doing everything magically. The real answer is more interesting.

AI was especially useful for:

• turning a rough idea into a scoped implementation slice
• reading the current state of the code before changing it
• iterating on Django views, templates, URLs, and workflow logic
• debugging regressions and broken assumptions
• cleaning up messy internal tooling
• helping with deploys and environment mismatches
• writing or revising docs so future work went faster
• carrying momentum across lots of small follow-up tasks

That last part mattered a lot. Odd$mith didn’t become more capable because one giant AI-generated patch appeared out of nowhere. It became more capable because OpenClaw could keep helping with the next useful thing, then the next one, then the next one, while staying grounded in the actual project.

What still required human judgment

This is the part that makes the whole thing real instead of hype.

AI did a huge amount of implementation and iteration work, but the human role never disappeared. It shifted.

The human still had to decide:

• what mattered enough to build
• which workflows were worth automating
• what should remain premium vs free
• when generated content sounded too stiff or too risky
• when product UX was getting too messy
• which changes were safe to deploy
• what needed approval before it went public
• where guardrails had to stay strict

That was especially true in a betting product. It’s one thing to automate scaffolding or UI polish. It’s another thing entirely to let generated sports content or betting recommendations drift into made-up specifics, unsupported claims, or careless automation. A lot of the later Odd$mith work was about tightening those boundaries, not just expanding what AI could do.

What AI was not good enough to trust blindly

This project also made one thing very obvious: AI can create broken systems very quickly if you let it operate without enough structure.

A few examples of where human oversight still mattered a lot:

• content had to stay grounded in actual event and odds data
• generated copy needed guardrails to avoid fake confidence
• deploys could drift between environments
• route/view/template mismatches could still sneak into production
• automations needed approval boundaries and sane defaults
• “works locally” was never enough by itself

The best results came when AI was treated as a fast implementation partner inside a constrained system, not as an oracle.

What surprised me most

The most surprising part wasn’t that AI could write code. That’s the least surprising part now.

The surprising part was how much useful product work it could do once it had:

• persistent context
• access to the real workspace
• the ability to inspect and modify actual files
• command-line access
• a running feedback loop with a human making product calls

At that point, the bottleneck shifted. The hard part stopped being “can this code be written at all?” and started becoming “what should be built next, what should be automated, and how do we keep the system coherent as it grows?”

That’s a much more interesting future for AI-assisted development than one-shot code generation.

The real takeaway

Odd$mith was not built by pressing a button and watching AI manufacture a startup.

It was built by using AI as a persistent co-builder inside the actual product: implementing features, revising workflows, debugging real issues, improving ops, and helping turn rough ideas into shipped slices.

That’s a much more practical and much more believable model than the usual AI hype. It’s also, in my experience, much more useful.

If the first phase of AI coding was about generating snippets, the next phase is about stateful product collaboration. That’s the part OpenClaw made real for this project.

If you want the earlier version of this story, read the original post: How I Built Odd$mith Almost Entirely With OpenClaw.

And if you want to see the underlying system behind this workflow, you can explore OpenClaw’s documentation.