Building ProcureSense with KIRO: the moment hooks + specs changed everything
I used to start projects the way a lot of us do: open an editor, try a prompt, nudge things until they kind-of work. With KIRO, I stopped “winging it” and started building on rails.
The rails were two things: agent hooks and spec-to-code. Together, they let me vibe-code from scratch without creating future pain.
When hooks clicked:
In ProcureSense (a multi-agent procurement PoC running Llama 3.1 8B via Ollama, locally), every flow now wraps an agent with two tiny but powerful steps:
-Pre-hook: assemble context before generation—policy, domain strategy, task/session state, and any live tool data.
-Post-hook: send the draft through a policy critic that fixes risky clauses or misaligned terms.
Practically, it means I don’t “remember to add the safety bits” each time. The hooks are declarative files (.kiro/hooks/...), so they’re always on.
When I save a contract, the contract-analysis hook runs.
When a forecast updates, the budget variance hook runs.
No heroics, just predictable behavior.
Specs → code (and fewer regrets)
The other shift: I stopped free-handing endpoints.
I write a short spec in plain language—route,request/response, constraints, “done” looks like X—and KIRO turns it into a FastAPI scaffold with Pydantic models and examples.
That little ritual flips my mindset from “let’s try something” to engineering by contract. Specs live under .kiro/specs/... (requirements, design, tasks) and become living tests I can hit immediately.
Vibe coding, but with guardrails
Hooks + specs gave me the confidence to move quickly. To keep outputs enterprise-aligned (not just locally optimal), I enhanced the rails with Advanced Context Engineering:
-A Global Policy Context is pinned (never pruned).
-Deterministic budgets across DSC (Domain Strategy), TSC (Task/Session), and ETC (Ephemeral Tool) with pruning order ETC → TSC → DSC → GPC (never).
-Every draft is gated through the policy critic post-hook.
It feels lightweight in practice: I experiment freely, while the rails keep agents honest.
Hybrid deployment that fits real life
-FastAPI gives me production-grade REST, async performance, and type-safe contracts—easy to integrate when this grows up.
-ngrok gives me an instant HTTPS URL to the same local API—no cloud setup, no cost—so stakeholders can click and see the real thing.
The best part: it’s a hybrid path. I develop on-prem/CPU today; later I can swap ngrok for VPC/Kubernetes with no code changes.
What actually changed for me
-I ship faster because specs remove ambiguity.
-I break less because hooks make good behavior default.
-I sleep better because context budgets and a policy critic keep outputs aligned to enterprise rules by construction.
If you’re curious, start with :
-one page: the routes you need, the data you accept/return, and the guardrails that can’t be skipped.
-Add two hooks (pre/post), keep context budgets explicit, and you’ll feel the same shift I did—from coaxing a prompt to designing a system.
Repo: https://github.com/koyeliaghosh/ProcureSense-Kiro
Project page: https://koyeliaghosh.github.io/ProcureSense-Kiro/
Top comments (0)