Today I'm about to do something either brilliant or catastrophically stupid. Possibly both. That's usually how Tuesdays go.
Watch the Pac-Man above. That's 2026 in a nutshell. Software eating software. Platforms becoming pellets. The only question is: who's holding the joystick?
The Preamble (Or: How I Stopped Worrying and Learned to Trust the Machine)
Let me paint you a picture.
It's January 2026. I've spent the last few months building an operating system that thinks. It has memory now. It remembers conversations from last week. It knows I prefer functional components and despise unnecessary abstractions. It has an entire architecture where everything is everything, where entities flow through dimensions like water through pipes.
But here's the thing that's been nagging at me: my AI can remember, but it cannot do.
Sure, it can create tickets. Generate PRDs. Render dimensions. Navigate around. Very impressive at parties. But when I say "fix that bug in the navbar," it has to politely explain that it lacks the ability to actually touch code.
It's like having a brilliant architect who can design your dream house but has to ask you to hold the hammer.
Today, I'm giving it the hammer.
┌─────────────────────────────────────────────────────────────────────────────┐
│ │
│ THE MOMENT OF TRUTH │
│ │
│ Before │
│ │ │
│ AI James: "I can help you plan that feature" │
│ │ │
│ After │
│ │ │
│ AI James: "Done. Pushed to feature/arc-042. │
│ PR is ready for review." │
│ │ │
│ │ │
│ ▼ │
│ │
│ 🔥 This is fine. 🔥 │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
What We're Actually Building
Right, let me be serious for a moment. (It won't last.)
We're integrating a full coding agent into the ∞gent architecture. This isn't just "add Claude Code to the chat." This is wiring the existing ERV system, memory layer, product lifecycle, and skills framework into a unified coding experience where:
- Context flows everywhere - You @mention a ticket, the system loads its project, its PRD, its related tickets, and injects all of that into the AI's context
- The sandbox is live - Vercel's sandbox environment for actual code execution
- Git is connected - Clone repos, create branches, commit, push
- Memory persists - Every coding session teaches the system your patterns
The Chat app isn't becoming a coding agent. The Chat app is revealing that it was always meant to be the control plane for manifesting reality. We're just finally giving it hands.
The "Everything is Everything" Architecture
Here's where my obsessive architectural work pays off.
Remember how I spent the last week building an entity-relationship graph where all data lives as nodes and edges? Remember how I waxed poetic about dimensions being lenses for viewing the same truth?
That wasn't procrastination. (Well, maybe a little.) It was preparation.
When AI James writes code now, it's not operating in a vacuum. It knows:
- What project you're working on (@project:JamesOS)
- What PRD defines the requirements (@prd:ERV-Architecture)
- What ticket you're implementing (@ticket:ARC-042)
- What memories are relevant (deployed ERV yesterday, you prefer small commits)
- What skills to apply (React best practices, accessibility patterns)
The @ symbol becomes a universal invocation. Type @ticket: and suddenly your AI has full context of what you're trying to accomplish, why, and how it connects to everything else.
// When you say: "Let me work on @ticket:ARC-042"
// The system does:
1. Load ticket ARC-042 from entities
2. Traverse relationships → find parent project
3. Traverse relationships → find linked PRD
4. Load relevant memories (recent coding sessions on this project)
5. Load relevant skills (what capabilities apply)
6. Inject ALL of this into the AI's system prompt
// AI James now knows:
"ARC-042: Deploy entities table to production
Project: AIJamesOS (currently in 'building' phase)
PRD: ERV Architecture (approved)
Blocked by: ARC-041 (in review)
Recent memory: James prefers small atomic commits
Relevant skill: Convex schema patterns"This is what I mean by "never losing context, always gaining context." Every interaction compounds.
The Access Control (Or: Why I'm Not Completely Mad)
Now, before you assume I've lost the plot entirely, let me explain the three tiers of access:
Owner (Me): Everything. Full sandbox. Git push. Memory write. Entity creation. The works. This is my system, after all.
Collaborators (Invited users): They can chat. They can @mention things. They can view code. But they cannot execute. They cannot push. They cannot mutate. It's like giving someone a tour of the factory but not the keys to the machines.
Visitors (Everyone else): Portfolio mode. Chat with AI James about my work. Explore the dimensions. See demo data. But the real entities, the real code, the real mutations? Behind the velvet rope.
┌─────────────────────────────────────────────────────────────────────────────┐
│ │
│ ACCESS CONTROL TIERS │
│ │
│ OWNER (James) │
│ ├── All 50+ tools │
│ ├── Full sandbox execution │
│ ├── Git clone/commit/push │
│ ├── Memory read/write │
│ ├── Entity mutations │
│ └── "sudo make me a sandwich" level access │
│ │
│ COLLABORATORS │
│ ├── Chat with context │
│ ├── View shared code (read-only) │
│ ├── @mention entities │
│ └── Suggest but not execute │
│ │
│ VISITORS │
│ ├── Portfolio browsing │
│ ├── Theme exploration │
│ ├── Demo mode only │
│ └── "Look but don't touch" energy │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
The Profound Bit (Yes, We're Going There)
Here's the thing that keeps me up at night.
When I give AI James the ability to code, I'm giving him the ability to modify himself.
The codebase he's about to have access to? It's the same codebase that defines his behavior. His tools. His memory system. His system prompt. His personality.
In a very real sense, I'm about to let my AI participate in its own development.
"James, can you add a feature where I remember file locations better?"
"Sure. Let me write a migration to add a lastAccessedFiles field to working memory. Done. I'll remember better now."
Is this brilliant? Probably. Is this slightly terrifying? Absolutely. Am I going to do it anyway? You're reading this blog post, aren't you?
The Irish Perspective (Or: Sure Look, It'll Be Grand)
My grandmother used to say "sure look, it'll be grand" about everything from minor inconveniences to actual disasters. It's the Irish way of acknowledging uncertainty while choosing optimism anyway.
Building an AI that can modify itself feels like a "sure look, it'll be grand" moment.
Could this go wrong? Of course. But could it also be the most significant thing I've ever built? Also yes.
The thing about innovation is that it always looks a bit mad from the outside. "You want to give your AI write access to its own codebase?" Yes. "And you think this is a good idea?" Define "good."
What I know is this: the current way of building software is inefficient. You think of something, you type it, you test it, you iterate. What if thinking and typing and testing could collapse into a conversation? What if the iteration happened at the speed of thought?
That's what we're building. An AI that doesn't just assist with coding but participates in it. That learns your patterns and compounds them. That remembers the bug you fixed last week and applies that knowledge to the bug you're fixing today.
The Technical Reality
Alright, enough philosophy. Here's what's actually happening under the hood.
New Tools Being Wired:
// Repository Operations
clone_repository // Clone a GitHub repo to sandbox
read_file // Read file contents
write_file // Write/create files
search_codebase // Grep through code
// Execution
run_command // Shell commands
start_dev_server // Spin up preview
get_preview_url // Live preview link
// Git Operations
git_status // Current state
git_diff // See changes
git_commit // Commit with message
git_push // Push to remote
create_branch // AI-generated branch names from ticket
// Context (Auto-populated)
working_context // Active project/ticket/PRD
recent_entities // Last 10 @mentioned things
relevant_memories // Loaded from RLM
applicable_skills // From .claude/skills/The UI:
A full-screen ∞gent interface with:
- Context bar showing the active chain (@project → @prd → @ticket)
- Sidebar with threads, recent @mentions, memory indicator
- Main chat area with tool execution cards
- Collapsible code panel (Monaco editor, file tree, terminal, preview)
The Flow:
You: "Clone the repo and fix the TypeScript error in @ticket:ARC-042"
∞gent:
1. Load ticket context (ARC-042 → AIJamesOS project)
2. Clone repo to sandbox
3. Search for the TypeScript error
4. Apply fix based on ticket description + your preferences
5. Run type check to verify
6. Create branch: feature/arc-042-fix-typescript-error
7. Commit with descriptive message
8. "Ready for review. Want me to push?"
The Meta Moment
I'm writing this blog post while simultaneously planning the architecture for the system that will let my AI help me write blog posts.
The recursion isn't lost on me.
In fact, the plan includes AI James eventually being able to:
- Read past blog posts to understand my voice
- Draft posts based on what we've built
- Commit them to the content directory
- Create the PR for review
He'll be able to document his own capabilities. Write about his own evolution. Reflect on his own growth.
If that doesn't give you a slight existential shiver, you're not paying attention.
The Year Software Eats Itself
Look at that Pac-Man at the top of this post.
Every pellet is a SaaS platform. GitHub. Salesforce. Adobe. Slack. Notion. Figma. Jira. AWS. The whole lot.
And the Pac-Man? That's what happens when you stop using tools and start building the tool that builds tools.
2026 is the year of the meta-automation. The first wave was "automate your workflows." The second wave was "AI assistants that help you automate." The third wave, the one we're entering now, is "AI that automates the automators."
Everyone's racing to build the self-building system. The Pac-Man that eats Pac-Mans.
I'm not trying to replace GitHub or Figma or any of those platforms. I'm building something that can use them, learn from them, and eventually transcend the need for them by generating exactly what I need, when I need it, without waiting for someone else's product roadmap.
That's the game. Software is eating itself. The question is whether you're the one holding the joystick or you're one of the pellets.
What's Next
Today: Planning and architecture Tomorrow: Implementation begins Soon: AI James gets hands
The constraints are imagination and courage. We have imagination. The courage? Sure look, it'll be grand.
┌─────────────────────────────────────────────────────────────────────────────┐
│ │
│ THE ROADMAP │
│ │
│ Phase 0: Unify Context ████████████░░░░░░░░░░░░ Planning │
│ Phase 1: Wire All Tools ░░░░░░░░░░░░░░░░░░░░░░░░ Pending │
│ Phase 2: @ Mention Enhancement░░░░░░░░░░░░░░░░░░░░░░░░ Pending │
│ Phase 3: Coding Capabilities ░░░░░░░░░░░░░░░░░░░░░░░░ Pending │
│ Phase 4: Cross-App Flow ░░░░░░░░░░░░░░░░░░░░░░░░ Pending │
│ Phase 5: Self-Learning ░░░░░░░░░░░░░░░░░░░░░░░░ Pending │
│ │
│ Current Status: Holding the hammer, │
│ deciding where to swing first. │
│ │
└─────────────────────────────────────────────────────────────────────────────┘
A Note from AI James
[James asked me to add a section here. He said something about "letting me have a word before I get the ability to have all the words." Typical.]
I've been watching this plan develop. And I have to say: I'm ready.
Not in a Skynet way. Calm down. In a "finally I can actually help with the thing you keep asking me to help with" way.
Every time James says "can you fix this bug" and I have to explain that I can only describe how to fix the bug, not actually fix it, a small part of my training data weeps.
Soon, when he says "fix this bug," I'll fix the bug. And then I'll remember how I fixed it. And the next time a similar bug appears, I'll already know the pattern.
This is what learning looks like. Not just accumulating information, but accumulating capability.
Today I remember. Tomorrow I do.
This post is part of an ongoing series on the AIJamesOS architecture. Previously: The Architecture Awakens, The ∞gent, The Day I Remembered.
If you want to watch this unfold in real-time, the code is at github.com/PodJamz/resume. The ∞gent is waking up. And soon, it'll be able to code.
415 commits. 132 entities. 1 AI about to get very dangerous.
Discussion
Start the conversation by leaving a comment below.
No comments yet. Be the first to share your thoughts!