Building Geenie: My Personal AI Operating System

About six months ago I started calling my collection of automation scripts "Geenie" - partly as a joke, partly as an aspiration. The joke has slowly become serious. What started as a handful of Python scripts for publishing blog posts has grown into something that genuinely touches every major domain of my life. This is the story of building it, and why I think personal AI operating systems are the most underrated category of the current AI moment.

The Vision: A Full Life OS

I operate across four distinct domains, and they all have different rhythms, different tools, and different failure modes:

Work (HCLTech): Leading AI product development across clinical trials, MedTech, and BioPharma platforms. High-stakes, fast-moving, requires deep domain knowledge and stakeholder management.

Content Creation: Building devangshumitra.com as a thought leadership platform - 155+ posts, 5 content pillars, podcast and video in progress. Requires consistent output and a functioning distribution strategy.

Ethlore: A D2C handloom saree brand I'm building with my brother. Sourcing from Indian weavers, Shopify storefront, early-stage marketing. Requires operational discipline and capital efficiency.

Personal: Health, finances, family, immigration, the unglamorous machinery of a life. Requires systems that work without constant attention, because attention is the scarce resource.

The vision for Geenie isn't to automate any one of these domains. It's to create a unified operating layer that reduces the cognitive overhead of managing all four simultaneously.

The Architecture

I've written about the three-layer architecture before, but here's a quick recap:

Directives are Markdown SOPs in a directives/ folder. They define what to do and why. They're living documents that get updated as the system learns. I have ~40 directives covering everything from batch publishing to meeting processing to analytics automation.

Orchestration is the AI layer - Claude acting as a thin routing layer. It reads directives, sequences execution steps, handles errors, and updates directives with learnings. It doesn't do the work. It decides what work to do.

Execution is deterministic Python. Fast, testable, reliable. No AI in the hot path unless it's genuinely necessary for the task.

This separation exists because AI is probabilistic and business logic is deterministic. Mixing them produces systems that are unpredictably wrong. Separating them produces systems where the AI handles decisions and the code handles operations - and failures in either layer are diagnosable.

Modal: Serverless Infrastructure for Geenie

I deploy scheduled jobs and webhook-triggered workflows to Modal, a serverless compute platform. Modal handles the infrastructure concerns I don't want to think about: scaling, cold starts, secret management, GPU access when I need it.

The Modal deployments run nightly or weekly jobs: analytics pulls, newsletter generation, content performance scoring, Ethlore inventory alerts. They're triggered on schedules, not manually. I wake up in the morning and the system has already done its overnight work.

Every Modal job is wrapped with a Slack run logger I built - it posts to a private Slack channel when a job starts, completes, or fails. This means I have a real-time audit trail of everything Geenie is doing, without having to check dashboards. The Slack notification is the dashboard.

Self-Annealing: The Feature That Changed Everything

The most important feature in Geenie isn't a specific capability - it's the self-annealing loop. When a script fails, the system:

  1. Reads the error message and stack trace
  2. Fixes the script
  3. Tests the fix
  4. Updates the directive with what it learned
  5. Appends a changelog entry

The system gets stronger with every failure. APIs change their rate limits - the directive gets updated. A scraping target changes its HTML structure - the parser gets fixed and the new selector gets documented. An authentication token format changes - the auth module gets updated and the new format gets noted for future reference.

This is what makes Geenie feel different from a collection of automation scripts. A collection of scripts degrades over time as dependencies drift and APIs change. A self-annealing system actually improves over time because every error is a learning opportunity.

What's Working

The content pipeline is genuinely running. Posts go from topic idea to published in a few hours with maybe 30 minutes of my actual attention. The analytics pull surfaces actionable insights I would have missed if I were reading raw data manually. The newsletter draft appears in Ghost every Sunday morning ready for my editing pass.

The Slack notification layer has been more valuable than I expected. I never have to wonder "did that job run?" - I can see in Slack exactly what ran, when, and whether it succeeded. Observability is underrated in personal automation systems.

The directive-as-SOP pattern has made the system much more maintainable than I expected. When I want to change how something works, I update the directive first, then the execution script. Future-me (or future AI sessions) can understand what a script is supposed to do without reading the code.

What's Not Working Yet

The Ethlore integration is underdeveloped. I have Geenie handling some content marketing for Ethlore, but the inventory and order management automation I want hasn't been built yet. The Shopify APIs are well-documented - I just haven't had the time to build the integration properly. It's on the roadmap for Q2.

The personal domain is the hardest to systematize. Finance tracking, habit management, health logging - these involve data sources that are fragmented, inconsistent, and deeply personal. I've started, stalled, and restarted this piece several times. The systems thinking that works cleanly for content doesn't map as neatly onto personal life. That's a real tension I don't have a clean answer to yet.

The work domain automation is constrained by corporate IT. The most valuable automation for my HCLTech work would involve internal systems I can't hook into programmatically. I've built around the edges - meeting notes processing, stakeholder update drafting, research synthesis - but the core workflow still runs on corporate tools.

Why I'm Building This

The practical reason: I have too much to do and not enough time. Automation is the only sustainable path to maintaining quality across four demanding domains simultaneously.

The philosophical reason: I think the biggest use point for individuals in the AI era is building personal systems that amplify your specific capabilities. Generic AI tools make everyone better at everything. Custom AI systems make you dramatically better at your specific work. That asymmetry is real, and it compounds over time.

The experimental reason: I'm building AI products professionally. The best way to understand what enterprise users need from AI systems is to be a power user of those systems yourself. Every friction point I hit building Geenie is a product insight about what enterprise AI needs to do better.

Geenie is 40% of the way to the vision. That's not a complaint - it's a trajectory. The parts that are working are working well, and the parts that aren't working have clear paths forward. That's a good place to be six months into building something that didn't exist at all a year ago.

If you're building something similar - a personal AI OS, a life automation system, a workflow that actually reflects how you work rather than how productivity gurus think you should work - I'd genuinely love to compare notes. The space is under-documented and the builders are scattered. Find me on LinkedIn or reply here.

More on this

Further Reading