From Spec To Vibe: How I Built An Agentic Prop Firm With Kiro (And What It Taught Me About AI Development)

#kiro #ai #nextjs #buildinpublic

If AI is going to be truly useful for builders, it needs to do more than complete tasks. It should nudge, anticipate, and sometimes argue. My ideal agent would interrupt me at 2 AM and say, “Hey, you’ve never written about Meta AI—are you ignoring them or just busy? I drafted a post—approve or rewrite?” I want systems that think with me, not just for me.

This post is the story of building a real product under real constraints—Aurum Prop Firm, an agentic trading platform—using Kiro as my primary co‑builder. It’s also a reflection on the tradeoffs: when spec-driven development works, when it fails, why vibe matters, and how to move fast without letting your skills and taste atrophy.

What I Built

A premium landing page and waitlist with motion, micro‑interactions, and a “feels like a product” sheen.
A serverless waitlist API backed by Neon (Postgres), with idempotent table creation, validation, and simple analytics.
OANDA integration via a thin HTTPS client: pricing, accounts, history, and order placement (no SDK, no dependencies).
A signed‑in dashboard (NextAuth credentials) with:
Take‑Trade flow (account → pair → direction) with live bid/ask, spreads, and journaling.
Spirit Journal for reasoning, with TradingView embedded.
Account history with live P&L and position summaries.
Payments via Korapay:
- USD→NGN conversion at initialization, webhook reconciliation, and automatic challenge‑account provisioning on success.
Admin panel for waitlist, users, OANDA account attachment visibility, and CSV export.
Utility scripts for DB setup/cleanup and OANDA diagnostics to iterate fast locally.

Tech used: Next.js (App Router), Neon (serverless Postgres), NextAuth (credentials), OANDA (HTTP API), Korapay (payments), TradingView widget, and a bunch of small Node scripts to keep me honest.

My Kiro Workflow (Vibe + Spec, in parallel)

I started with spec-only. It didn’t work. The UI was flat and lifeless—technically correct, but emotionally wrong. Big lesson: “correct” is not the same as “compelling.”

The switch flipped when I realized I could vibe and spec at the same time:

Vibe: “Make a cinematic landing with depth and motion—animated chart, scroll-in features, sticky nav, and tasteful gold accents.” Kiro produced a polished front page, complete with animated hero and micro‑interactions. I iterated with follow-ups like “reduce friction on load,” “tighten type scale,” “add trust stats.”
Spec: “Create POST /api/waitlist with Neon; validate email; idempotent table creation; capture IP and UA; return queue position.”

Kiro implemented the endpoint and the DB helper I needed, and we tested through edge cases together.

For integrations, I did what I always do: I go to the vendor docs, copy them into a .txt file in my repo, and tell Kiro to read and build. That’s how the OANDA HTTPS client emerged—no heavy SDK, just a well-factored module with good error handling. Same for Korapay: init route with USD→NGN conversion, webhook reconciler, and a provisioning flow that creates a challenge account with derived targets/drawdown once payment clears.

I didn’t use Kiro hooks. I started late and didn’t want a new abstraction layer. Instead, I leaned on plain API
routes, scripts, and conversations. It kept my loop fast and predictable: I’d paste docs, say “implement safely
with good errors,” and then vibe the UX on top. Simple and effective.

What The Product Actually Does

Landing + Waitlist: Premium hero with animated chart motif, scroll‑in features, and a smooth CTA. Submissions go to the waitlist table with IP/UA capture, duplication checks, and a “position in queue” response. Nice touches, no heavy backend complexity.
Trading Dashboard:
- Accounts populate via DB (provisioned through payments) and OANDA linkage. Active accounts are visually distinctive and selectable.
- Live pricing polls every few seconds for majors, pausing on weekends. It maps instruments cleanly (EUR_USD ↔ EUR/USD), shows spreads, and avoids stale state.
- Take-Trade flow enforces discipline:
- Before placing an order, you must journal a reason (modal), which is then saved as a first‑class artifact.
- Risk sizing is server-side (0.25%) with pip-aware logic, including JPY math. SL/TP is auto-computed by plan (Standard 1:3, Pro 1:6).
- There’s a one‑trade‑per‑session rule (NY/London/Tokyo/Sydney UTC windows). When it trips, you get clear guidance and a timestamp of the prior trade.
- Orders are validated against live OANDA pricing; client-supplied prices are ignored. On OANDA rejection (FIFO/opposing positions/margin), the error reason is surfaced unmodified.
History shows trades with formatted prices, units, and live unrealized P&L for open positions.
Payments + Provisioning:
- Initialization uses Korapay’s rate endpoint to convert USD to NGN (with a fallback rate if needed).
- Webhook merges payload with stored order metadata and auto‑creates a “challenge” trading account with derived profit targets and max drawdown, based on plan and size.
Admin:
- Waitlist viewer, CSV export, user creation, OANDA account attachment visibility, and provisioning review. Enough to run operations without SSHing into a database.

Where Spec Helped (And Where It Didn’t)

Spec excelled in all the backend boundaries:

Waitlist: input validation, idempotent table creation, predictable response shape.
OANDA: clean error mapping (401/403/503), ID normalization, “no price, no trade” logic.
Trading: risk sizing, pip logic, plan-based SL/TP, session windows.
Payments: USD→NGN conversion details, webhook reconciliation, and deterministic provisioning.

Spec didn’t give me a good UI. My first spec‑only pass looked like an admin back-office. Correct, but not
convincing. The moment I paired spec with vibe, velocity and quality snapped together. Spec made edge cases and
contracts reliable; vibe made it feel like something I want to use. That combo gave me a product that’s both
sturdy and expressive.

The Most Impressive Thing Kiro Generated

The trade pipeline. It’s end-to-end “prop rules, but real”:

Live mid‑price resolution with sensible fallbacks and crisp logging. If there’s no price, no trade. If it’s the weekend, wait. If OANDA rejects the order, surface the exact reason (not a vague interpretation).
Risk sizing at 0.25% with pip‑aware math and JPY conversions handled correctly.
SL/TP rules computed server‑side by plan and instrument with correct decimal precision (7/21 pips for Standard, 7/42 pips for Pro).
One‑trade‑per‑session, using real UTC session windows for NY, London, Tokyo, Sydney, with helpful messaging and the prior trade’s timestamp.
Persistence that respects the story:
- Order record with OANDA/ sizing metadata.
- Trade record after a fill, with entry and SL/TP locked in.
- A journal entry that stores your “reason” as a first‑class artifact (this is big for discipline).
- A follow‑up stats update that keeps the account state honest.

Runner‑up: the Korapay flow. It turns an API → receipt → account provisioning story into a clean, auditable
path. The init route handles conversion and references. The webhook carefully merges payload with stored
metadata, updates status, and creates a configured “challenge” account with derived parameters. It’s the kind
of plumbing that makes your business real.

Why I Skipped Kiro Hooks (And What I’d Automate Later)

I didn’t use Kiro hooks for this project. Starting late, I optimized for predictability and speed:

No hook DSL to learn.
Fewer integration seams to debug.
Scripts and API routes I could run and verify immediately.

What I’d consider next time:

Hooks for periodic health checks (OANDA connectivity, DB migrations).
Hooks to enforce CI‑style validations (route contracts unchanged, environment guards).
Hooks for doc ingestion pipelines (e.g., “auto-reindex vendor docs and lint API clients against them”).

In short: hooks could help, but for a sprint, fewer layers meant fewer surprises.

The Hidden Cost Of AI Development (And How I Avoided It Here)

In a previous essay, I called out the real cost of AI‑augmented development: it can make us faster while
quietly dulling our instincts. The “spidey sense” you earn from wrestling with systems—debugging deep,
untangling edge cases—can atrophy if you never have to sit with a problem.

Two ideas helped me keep that edge:

Interruption as education. I design my workflows so I can pause the machine. Whether it’s a long-running generation, a loop, or a pipeline, I want to see intermediate state. That’s how I catch wrong assumptions (mine or the AI’s).
Traceable boundaries. Spec the contracts and keep logs that matter. When something’s off, these give me the x‑ray I need to reason instead of flailing.

Agentic frameworks (LangGraph, CrewAI) move in the right direction—visible, interruptible flows. But even the
best tool‑calling model will get environment assumptions wrong. The answer isn’t blind trust; it’s interactive,
inspectable systems you can steer in-flight.

Also: token accounting is still a mess in multi‑agent builds. If you’re trying to understand cost dynamics,
you’ll likely be instrumenting your own traces. Plan for that.

What I’d Do Next

Explore Kiro hooks for scheduled health checks, schema drift detection, and contract tests for critical APIs.
Add a lightweight observability panel to track pricing health, order latencies, and payment → provisioning funnels.
Evolve Spirit Journal into a true coaching agent that synthesizes your trade reasons with market context and suggests improvements over time.
Harden test coverage around the most sensitive flows (payments, order placement, and OANDA error handling).

Closing

I used Kiro as a force multiplier, but I didn’t outsource taste or judgment. Spec made the platform reliable.
Vibe made it compelling. Scripts and routes kept me honest, fast, and focused. And I skipped hooks—not forever,
but for this sprint—because I wanted fewer moving parts while shipping something ambitious on a deadline.

If you’re building with AI: