Skip to content

Architecture

From business intent to production.

AI-native product engineering is a disciplined lifecycle: agents execute meaningful work across every stage while I retain product judgment, accountability, and release authority.

Let's talkReview selected work
AOHYS production systemA signal enters. The system keeps its context and reaches production with a visible release record.
  1. 01
    Public experience

    Bilingual site, cases, services, and accessible interaction

    Astro · EN / ES
  2. 02
    Content, dashboard, and data

    Publishing, ownership, and shared content contracts

    Content Graph · Convex
  3. 03
    Media and edge

    Published images, versioned fallbacks, and fast delivery

    Cloudflare
  4. 04
    Signals and contact

    Requests, analytics, and errors with explicit boundaries

    Form · PostHog
  5. 05
    Release train

    Preview, checks, promotion, and production smoke

    develop → main
Architecture

One lifecycle, six accountable stages.

The sequence makes decisions, dependencies, verification, and release boundaries visible. AOHYS is one public implementation of this practice—not the limit of the architecture or a map of the private Development System.

  1. 01

    Business intent

    Listen to the business, clarify the user outcome, surface constraints, and grill ambiguous language before choosing a technical path.

    • Business intent
    • Stakeholder context
    • Grilling
    • Outcome definition
  2. 02

    Domain & decisions

    Model the domain, name stable concepts, compare tradeoffs, and record the decisions that shape the product and system.

    • Domain modeling
    • Architecture decisions
    • Product boundaries
    • Tradeoffs
  3. 03

    Specs & dependency graph

    Turn the agreed direction into specs, executable tickets, ownership, acceptance seams, and dependencies that preserve the right order.

    • Specs & tickets
    • Dependency graph
    • Acceptance criteria
    • Release boundary
  4. 04

    Agent implementation

    Specialized agents research, implement, test, and review bounded work. The human orchestrator integrates evidence and resolves the decisions tools cannot own.

    • Agent implementation
    • Specialized review
    • Context engineering
    • Human orchestration
  5. 05

    Verification & browser QA

    Use proportional TDD, linting, type checks, behavior tests, independent review, and browser QA to verify the real user-visible result.

    • TDD
    • Code review
    • Browser QA
    • Visual evidence
    • Observability
  6. 06

    Preview to production

    Build a Preview Deployment, collect human review, promote through the Release Train, verify the Production Deployment, and run smoke checks.

    • Preview Deployment
    • Release Train
    • Production Deployment
    • Smoke checks

Architecture is a sequence of tradeoffs.

  1. 01

    Agent execution with human accountability

    Agents can expand execution capacity, but they cannot own business intent, risk acceptance, or release authority.

    I remain responsible for what gets built, how it is verified, and whether it is ready to ship.
  2. 02

    Public explanation without publishing the private tool

    The lifecycle should be inspectable without exposing private instructions, operating methods, or delivery details.

    The Development System remains private and adaptable; shipped products and sanitized artifacts provide the evidence.
  3. 03

    Preview before production

    A green build does not prove that a release works in its real environment.

    Protected promotion, a Preview Deployment, human review, and smoke checks make production a separate decision.

Operating notes

The seams that keep the topology connected.

  1. 01

    Human accountability

    Agents execute requirements work, modeling, specs, tickets, implementation, tests, review, and QA. Alejandro retains product judgment, integrates the evidence, and authorizes release.

  2. 02

    Public Source Site and Private Work

    The Public Source Site makes AOHYS implementation choices inspectable. Private Work—including client code, data, operational screens, credentials, and the Development System—remains private.

  3. 03

    Release Train

    A Preview Deployment is built and reviewed first. Production moves through a separate promotion with explicit authority, environment checks, deployment verification, and smoke checks on the canonical domain.

  4. 04

    AOHYS as a visible implementation

    AOHYS demonstrates localized public routes, authenticated private workflows, typed content, observability, and a protected release path. It is one concrete example of the broader professional architecture.

  5. 05

    Private Development System

    The Development System coordinates tools and agents across different coding environments. It is private, not open source or a commercial template, and every team should adapt its own practice.

  6. 06

    Production feedback

    Observability, analytics, errors, smoke checks, and stakeholder feedback return real behavior to the next product decision instead of treating release as the end of the lifecycle.

Tell me what you're building.

Tell me what you are building, who it should serve, and what is getting in the way. I will read the context myself and reply with useful questions and a practical next step.

Let's talk