hcode
hcode is a local Mac desktop IDE built with Tauri, Rust, React, and Vite that orchestrates Claude, Codex, and Antigravity through a fixed 7-stage SDLC sequence. Each stage assigns one model a non-overlapping role: Claude owns the spec and reviews the diff, Codex pressure-tests the spec and writes tests before implementation, and Antigravity builds and runs the execution harness. A deterministic script gate at L7 measures the repository and emits a merge verdict without delegating that judgment to a model. The tool maintains isolated worktrees per agent slot, surfaces cross-worktree conflicts in a Monaco diff viewer, and aggregates terminal permission requests into a single review bar. Users supply their own Claude, Codex, and Grok credentials; hcode itself is available as a free download on GitHub.
hcode is an AI code tool, integrating with Claude, Codex, Antigravity and Grok. InnovaAI rates it 3.5 of 10 for agency adoption, best for Founder, Operations and Project Manager roles.
Agency Audit
hcode is a local desktop IDE that routes code work through a seven-stage SDLC where different AI agents (Claude, Codex, Antigravity) occupy distinct roles: spec owner, adversarial reviewer, test author, implementer, code reviewer, execution harness, and deterministic merge gate. An agency with one or two engineers shipping features can adopt hcode to compress solo-developer workflow into a disciplined handoff sequence, catching specification drift and merge conflicts before they reach the base branch. Best fit: agencies where a single developer or small engineering team owns feature delivery end-to-end and currently lacks structured code review or test-first discipline.
1recommended
14/mo
No paid plan published
Moderate
Illustrative scenario. Not a guarantee. Net capacity needs a verified paid base plan, and none is published for this service, so it is not modeled. Hours saved come from the service estimate; implementation, taxes, and unprovided usage charges are excluded.
- Founder handling internal tooling development
- Operations handling spec authoring and version control
- Project Manager handling code review and merge validation
- Your agency has three or more engineers collaborating on the same codebase in parallel. hcode is designed for solo or one-person engineering; it does not coordinate human-to-human handoffs or resolve concurrent edits across multiple developers.
- Your engineering workflow already includes a formal code-review process, automated testing pipeline, and CI/CD gate. hcode adds process overhead if those guardrails are already in place.
- Your team does not use Claude, Codex, or Antigravity subscriptions, or you cannot bring your own API credentials. hcode requires active subscriptions to the agents it orchestrates.
Internal Adoption Path
No paid plan published
14 hr/mo
1 seat × 14 hr each
$1,050/mo
modeled at $75/hr labor rate
No paid plan published
Illustrative scenario. Not a guarantee. No verified paid base plan is published for this service, so subscription cost and net capacity are not modeled. Implementation, taxes, and unprovided usage charges are excluded.
Platform Features
Core capabilities of hcode
7-Stage SDLC Orchestration
Routes Claude, Codex, and Antigravity through spec ownership, adversarial review, test authoring, implementation, code review, execution, and a deterministic gate in sequence. A solo engineer or Founder acting as FDE gets a repeatable handoff chain without managing a full engineering team.
Spec Freeze and Versioning
Locks the specification artifact after L2 adversarial review so later roles cannot silently rewrite the target. Project Managers gain a timestamped contract to reference when scope questions surface during or after a build.
Deterministic Merge Gate
A script-based L7 gate measures the repository and emits a merge verdict without delegating that judgment to a model. Engineers and Founders get evidence-backed go or no-go decisions rather than model-generated opinions.
Cross-Worktree Conflict Preview
Detects overlapping edits across isolated agent worktrees and surfaces them in a Monaco diff viewer before the base branch is touched. Operations leads shipping internal tooling can catch integration collisions during review rather than after a broken merge.
Unified Permission Review Bar
Aggregates approval requests from all active terminal streams into a single review surface so the engineer answers yes or no without hunting across panes. This reduces context-switching overhead for whoever is running multiple agent slots simultaneously.
Isolated Agent Worktrees
Assigns each agent slot its own worktree so supporting work stays contained and legible. A solo engineer managing spec, test, and implementation work in parallel can inspect each agent's output without the branches bleeding into each other.
What Makes hcode Different
Unique advantages vs similar tools in this niche
Role-based lifecycle with author ≠ checker invariant
vs Single AI model doing all tasksClaude owns specification and reviews diffs; Codex pressure-tests specs and writes tests before code; Antigravity implements and runs execution harness.
Deterministic merge gate measures actual repository
vs Model-declared success or public benchmark scoresEvidence comes from the actual checkout, not public benchmark scores, and no model owns the final merge decision.
Conflict-aware review with cross-worktree collision alerts
vs Manual terminal tab managementPreview merge conflicts without changing the checkout, and the ordered integration queue stops at the first conflict so later branches remain untouched.
Latest Updates
Recent releases and improvements for hcode
hcode 0.1.5 available on GitHub
Newhcode 0.1.5 is a local desktop IDE built with Tauri, Rust, React, and Vite. Supports running Claude, Codex, Grok, Agy, or a shell in a slot with your own subscriptions and credentials.
Value Equation
Outcome-likelihood-time-effort assessment for hcode
Value math requires real pricing
The Value Equation (dream outcome × likelihood ÷ time × effort) feeds directly into ROI math. hcode has no published pricing, so we hold this section until real numbers are available.
Contact hcodePricing
Pricing data not yet available for hcode.
Reality Check
hcode requires the adopting engineer to commit to the seven-stage workflow and accept that each stage has a single accountable role; teams accustomed to ad-hoc agent use or parallel model invocation will need to retrain. The tool is optimized for solo or one-person engineering, not for coordinating across multiple human developers.
Moderate effort: standard configuration with some customization needed
How This Accelerates White-Label Services
Who It's For
- ✓solo-developers-and-one-person-engineering-teams
- ✓small-agencies-scaling-single-engineer-productivity
- ✓forward-deployed-engineers-fdes
Acceleration Steps
- 1Create your account and complete setup wizard
- 2Configure orchestrate multiple ai coding agents (claude, codex, antigravity) through a 7-stage sdlc workflow
- 3Connect Claude
- 4Launch your first client project
Academy for hcode
Work through it in order: the course for this service first, then the modules behind it.
Course for this service
hcode Agency Implementation, Multi-Agent Code Delivery at Scale
Learn how to structure client projects around hcode's 7-stage SDLC orchestration, assign Claude, Codex, and Antigravity to distinct roles, and deliver deterministic code reviews without model drift. This course teaches agencies how to productize hcode as a repeatable delivery system for custom development retainers.
Open the courseNo Academy modules are published for this service yet. Browse the full Academy
Core concepts
The mental model you need to price and scope the work.
- Scaffold Versus Steward SplitConcept
AI code tools compress the cost of producing a first working version, but they do not compress the cost of owning it. The Scaffold Versus Steward Split separates two jobs agencies have historically billed as one: scaffolding (generating a full-stack app, wiring auth and payments, standing up a prototype) and stewardship (architecture decisions, review, and keeping consumer code in sync when contracts change). Scaffolding is where the speed advantage lives. Stewardship is where retainer value and liability live. Verdent illustrates the first half, turning a plain-English description into a working product with authentication, payments, and an admin dashboard. Ripple illustrates the second, detecting a breaking API change and opening pull requests across every affected repository. Agencies that price both halves at the same rate give away the margin on scaffolding and undercharge for stewardship. Split the two in your statements of work, and staff them differently.
- Agent Output Liability LineConcept
The Agent Output Liability Line is the boundary between code an agency can ship under its own name and code that still needs a human signature. Agentic tools now generate full-stack applications from prompts and auto-fix breaking API changes across repositories, which moves the liability question from 'did we write it' to 'who reviewed it.' Agencies that blur this line absorb client risk without pricing it. A practical test: if an agent opens a pull request at 2am and no human reads the diff before merge, that code sits above the line and belongs in a maintenance retainer, not a fixed-scope build. Tools like Agent Monitor and Agent Desk exist specifically to make that review boundary visible by surfacing per-file risk levels and session histories. The framework matters because delivery speed without a defined liability line converts margin into unpaid warranty work.
- Verification Debt CompoundingConcept
Verification Debt Compounding treats every unreviewed agent-generated commit as a small loan against future delivery capacity. The interest rate is set by how far the code drifts from the architecture a human would have chosen. Agencies that ship agent output straight to client repos accumulate this debt quietly, then pay it back in emergency debugging during a retainer sprint. The category description warns that over-reliance risks code quality inconsistency, and the operational evidence supports it: Agent Desk launched as an open-source macOS app specifically so teams can browse and review sessions across Claude Code, Cursor, Codex, and GitHub Copilot, which only matters if review is a scheduled step rather than an afterthought. A 10 MB in-browser model from GenClass now flags silent CSS and race-condition bugs that never throw errors, the exact class of defect that passes agent self-tests and lands in production. Budget review time as a line item, not a contingency.
Decision and risk
How to judge the fit, and the ways it goes wrong.
- When Agent Output Ships Unreviewed, Cap the Blast Radius FirstEvaluation Rule
Set a hard blast-radius limit per agent run, then require a named human reviewer before any change merges into a client branch.
- AI Code Tools Rule: Price the Maintenance Tail Before the ScaffoldEvaluation Rule
Before committing a client retainer to AI-generated code, estimate the 12-month maintenance cost of that code and confirm the tooling or team can absorb it.
- AI Code Tools Decision: Scaffold-and-Review vs Autonomous Agent DeliveryDecision Framework
IF your delivery model bills fixed-scope builds on 4 to 8 week timelines and your senior engineers can absorb review load, THEN use AI code tools for scaffolding and maintenance while keeping architectural sign-off human. IF your margin depends on autonomous agents shipping unattended across client repos, THEN you need session-level audit tooling and a named fallback model before you take the retainer.
- The Silent Regression Trap: Why AI Code Tools Pass Review and Fail in ProductionFailure Pattern
- The Scaffold-Without-Owner Trap: Why AI Code Tools Stall After the First SprintFailure Pattern
Delivery system
Blueprints and procedures for running it as a service.
- Agentic Code Delivery Pilot (10-15 days)Implementation Blueprint
A fixed-scope pilot that puts AI code tools behind human architectural review on one live client codebase, so an agency can quote faster delivery without betting a retainer on unreviewed output.
- Agent Output Review Gate (QA)Operating Procedure
- Agent Session Audit and Cost Reconciliation (Retention)Operating Procedure
- Scaffold-to-Production Promotion Gate (Delivery)Operating Procedure
13 modules selected for hcode
Frequently Asked Questions
Answers about pricing, setup, implementation
hcode is a local Mac desktop IDE that runs Claude, Codex, and Antigravity through a 7-stage SDLC workflow, assigning each model a distinct role: spec ownership, adversarial review, test authoring, implementation, code review, execution, and a deterministic merge gate. It keeps isolated worktrees per agent, surfaces merge conflicts in a Monaco diff viewer, and emits a script-based merge verdict at L7. The human engineer retains final judgment at every handoff.
No pricing figures appear in the available product information. hcode 0.1.5 is distributed as a free download on GitHub. Users are required to bring their own subscriptions and credentials for Claude, Codex, Grok, and Antigravity, so model costs are separate from the hcode application itself.
The Founder or solo engineer acting as a Forward Deployed Engineer gets the most direct benefit, since hcode is explicitly designed for one-person engineering at SDLC scale. An Operations lead responsible for shipping internal tooling without a QA resource benefits from the L3 blind test-authoring stage. A Project Manager gains a versioned spec artifact after L2 freeze, which provides a documented handoff trail for internal builds.
A conservative estimate for a solo engineer running the full L1-L7 cycle is 3 to 5 hours per week saved on manual conflict resolution, spec-drift correction, and context-switching across agent outputs. That estimate is based on the tool's stated workflow compression, not a vendor-reported or independently measured figure. Actual savings depend on how frequently the engineer ships new features and how much time they currently spend on merge and review work.
Setup requires downloading the Mac app from GitHub and connecting existing Claude, Codex, and Grok credentials. There is no server provisioning or team-wide configuration. A single engineer can be operational within an hour, though internalizing the 7-stage SDLC discipline and spec-freeze habit adds a learning curve of roughly one to two full build cycles.
The spec-freeze requirement at L2 is the primary habit change. Engineers accustomed to iterating on requirements mid-build will need to front-load their thinking before implementation begins. The tool also requires managing separate credentials for each model, which adds a one-time configuration step and ongoing subscription management for whoever owns the agency's AI tooling.