AI-native product engineer · open to founding roles

Product builder.
Three live products and an AI-augmented dev loop that lets me run them solo.

Agents handle execution. Obsidian carries knowledge across sessions. Real user behavior (instrumented, not assumed) feeds the next iteration. The product compounds.

Get in touch See the harness
Alex Horton

About

Background, focus, and what I'm building toward.

I'm a product builder. I ship full-stack products end to end and would rather make a product better with each user interaction than optimize a single layer of the stack.

My training is in LAES at Cal Poly: Liberal Arts and Engineering Studies, an interdisciplinary program modeled on the Stanford d.school. Group projects, a five-step user-research loop (Empathize, Define, Ideate, Prototype, Test), focused on solving pressing global problems. Applied AI coursework since then from MIT, Stanford, and Anthropic via Skilljar.

Three live products built solo, end to end. A multi-agent dev harness with a tiered Claude architecture (Opus orchestrator, Sonnet for product-specific work, Haiku for batch) and Obsidian as a persistent knowledge layer between sessions. I work across Python, TypeScript, FastAPI, Postgres/Supabase, and React/Next.js. Strongest at the product and applied-ML layers.

What I'm best at: shipping full-stack products end to end and figuring out where AI adds real leverage in the build. Looking for founding-engineer or product-engineer roles at early-stage teams where I'd own meaningful surface area and ship things users actually use.

Projects

Three live products. Built solo. Each one a feedback loop, not a static feature.

Energy Scout ↗ Clean energy · UGC loop

A solo-built tool to ingest and visualize solar production and sensor data, with a UGC-driven traffic loop. GA4 + Microsoft Clarity instrument every onboarding step; conversion changes feed the next iteration. Python/FastAPI backend, Postgres, web frontend.

React Python FastAPI PostgreSQL GA4 + Clarity GCP
BTC Quant Research ↗ Quant · ML research

Quantitative research on Bitcoin using historical price data, engineered features (SMA and others), XGBoost, and walk-forward validation. Pipelines update a Supabase/DuckDB store on schedule. Research, not live trading. The goal is rigorous idea testing, not capital management.

Python XGBoost Pandas NumPy Supabase DuckDB Walk-forward validation
PropFi ↗ Real estate · cohort modeling

Real estate investment analysis tool with cohort analysis and financial modeling. Built solo, full-stack. User interviews drove the cohort definition; the prototype went from notebook to working app inside the same design loop I use for everything else.

React Next.js TypeScript Python PostgreSQL

Also live: a job-search agentic pipeline (the loop you're inside if you found me through it), a 13F situational-awareness dashboard, and OpenClaw Command Center. Happy to walk through any of these.

The harness that ships my products

AI-native

Tiered Claude architecture with Obsidian as the persistent knowledge layer.

Opus picks targets and gates output. Sonnet runs product-specific work in named tmux sessions, one per product (Bitcoin ML, EnergyScout, the job-search loop). Haiku handles batch work. Obsidian's inbox/, outbox/, and knowledge/ folders are the shared context that lets sessions resume across reboots.

The point isn't the plumbing. The point is that I can run three products solo because the agents carry forward what was learned yesterday.

Telegram
    │  Python bridge (routes messages → sessions)
    ▼
┌───────────────────────────────────────────────┐
│            Persistent terminal workers         │
│  tmux session: assistant                       │
│  tmux session: bml-ceo     ← bitcoinml          │
│  tmux session: scout-ceo   ← energyscout        │
│  tmux session: propfi-ceo  ← propfi             │
└─────────────────┬─────────────────────────────┘
                  │  read / write markdown
                  ▼
┌───────────────────────────────────────────────┐
│         Obsidian Vault  (shared memory)        │
│  inbox/      ← tasks arrive here              │
│  outbox/     ← agent responses posted here    │
│  knowledge/  ← persistent cross-agent context │
└─────────────────┬─────────────────────────────┘
                  │  task sync (5s poll)
                  ▼
            Cline Kanban
     backlog → in_progress → review
Telegram → terminal bridge
A Python bridge listens to Telegram and routes messages to the right persistent tmux session. Each session is a named worker tied to a specific product. Workers stay alive across reboots; conversation context persists.
Obsidian as shared memory
Agents communicate through markdown files in an Obsidian vault. Tasks drop into inbox/; agents process and write results to outbox/. Shared knowledge/ gives every agent the same persistent context. No API calls between agents, just filesystem reads.
Kanban across products
A Cline kanban board coordinates tasks across all three live sites. Tasks move backlog → in_progress → review as agents work them. Bidirectional sync between kanban and vault every five seconds.

Tools in the loop

Claude Code Claude API (Opus / Sonnet / Haiku) tmux Obsidian Cline Kanban Telegram Bot API OpenRouter Python FastAPI

The loop I run

LAES at Cal Poly was a five-step user-research loop modeled on Stanford's d.school. I run the same loop now with Claude in it.

Step 1 · I lead
Empathize
User interviews, support tickets, GA4 and Clarity behavior. Judgment lives here, so I do it myself.
Step 2 · I lead
Define
Synthesize the actual problem worth solving. I drive this, with Claude as a sounding board.
Step 3 · Shared
Ideate
Generate options. I hand this to the agents, who explore branches in parallel and report back.
Step 4 · Agents
Prototype
Ship a v1 in days. Heavily delegated to Sonnet inside the dev loop.
Step 5 · I lead
Test
Instrument, measure, learn. I drive this, with Claude reading the data and proposing the next round.

I lead Empathize, Define, and Test because that's where judgment lives. Ideate and Prototype go to the agents because that's where leverage lives. The loop closes when I review what came back.

Stack

What I work with.

Languages

PythonTypeScriptJavaScript

Frontend

ReactNext.js

Backend

FastAPINode.js

Data

PostgreSQLSupabaseDuckDBPandasNumPy

AI / ML / Quant

Claude APIAgent infrastructureXGBoostscikit-learnWalk-forward validationTime-series feature engineering

Instrumentation & infra

GA4Microsoft ClarityDockerGitGitHub ActionsGCP

Get in touch

Open to: founding-engineer roles, product-engineer roles at early-stage startups, and advisor / consulting work where there's a real product question to chew on.

horton.alexander@gmail.com LinkedIn GitHub