"Jarvis" is the name Ron gave to his OpenClaw instance.
Write the spec, not the code. Let the AI figure out the rest.
Ron writes specs, Jarvis (an AI agent) does the work — websites, research, PRs, monitoring — and reports back each morning. Ron reviews in ~30 minutes. The agent proposes, never acts alone. 10 interruptions/day max. Safety enforced by code, not prompts. "Think deeply, output lightly."
Ron treats his AI agent (Jarvis) like a junior co-founder, not a tool. Instead of prompting it with tasks, he writes specifications: what the product should do, how it should behave, what matters and what doesn't. The agent reads these specs and proposes tiny improvements as GitHub pull requests, 1-2 lines at a time (see tiny-pr-bot). But PRs are just one output. Jarvis also monitors social media and GitHub activity nightly, evaluates new tools and frameworks, manages research bookmarks, and surfaces only what matters each morning.
The workflow protects Ron's scarcest resource: attention. An attention credit system (10 free + 20 earnable daily) hard-caps how much the agent can demand. Capture mode costs zero credits — Ron fires off ideas via voice without engaging, and the agent files everything for overnight processing. Only the final summary costs credits. Safety rails are enforced by code, not by asking the AI to remember rules. The agent has no direct write access to anything, only PRs that Ron approves.
Most users hand their AI agent root access and full data permissions on day one. Ron does the opposite: information is need-to-know, and access is earned incrementally. The agent has no direct write access to anything — not repos, not messaging, not external APIs. Every mutation goes through a code-level guard that validates, logs, and can be audited. Rules live in enforced scripts, not in prompts the AI might forget. Trust is earned through structure: the agent proposes, the human approves.
Backups run at two levels: Railway's built-in backup system on the Pro tier, plus a bidirectional sync to a private GitHub repo. The workspace is the source of truth — if the container dies, everything rebuilds from git.
Debugging is deliberately low-tech. When something breaks, Ron copy-pastes state into ChatGPT, asks Jarvis to export logs, searches for how to extract the right diagnostics, and iterates. No custom observability stack — just persistence and multiple AI assistants cross-checking each other. When a bug turns out to be upstream, he opens an issue rather than working around it silently.
When something breaks, Ron uses a separate AI (usually ChatGPT) as an independent verifier — never trusting the agent that might have caused the problem to diagnose itself. The loop: gather logs and state from Jarvis, paste into ChatGPT, run deep research, form a hypothesis, gather more data, repeat. Multiple AI assistants cross-checking each other catches things a single agent misses.
When the root cause turns out to be upstream, Ron opens a bug and tracks it. The agent monitors open upstream issues and notifies only when there's new activity.
The philosophy is top-down: spec first, then tests, then architecture, then code. Most of the code doesn't exist yet, and that's intentional. The spec IS the product at this stage. The agent's job is to sharpen the spec until building becomes obvious. Ron calls it "think deeply, output lightly."
Spec-driven development (SDD) flips the traditional workflow: instead of writing code and documenting it later, you write specifications first and let AI agents generate the implementation. The spec becomes the source of truth, not the code.
GitHub's SDD toolkit. CLI-based: constitution → specify → plan → tasks → implement. 40+ extensions.
Lightweight spec-driven framework. Three-phase state machine with spec deltas. 20+ AI tool integrations.
Full agile AI framework. 12+ specialized agents, 34+ workflows, scale-adaptive planning.
v0.2-staging