Hacker
Yash Dedhia
@yashhh_23
I am into building systems with clean code!
Elsewhere
Stack
- Java
- Python
- JavaScript
- TypeScript
- Go
- SQL
- Docker
- AWS
- React
- Render
- Vercel
HeatFlood Guardian: Climate Aware Navigation for Heat and Flood Resilience
Environmental HacksOct 2026
ENV-entors@anurag1,@sahil_rane
Rescue-Link: Offline First Disaster Emergency Response & Tactical AI Command Platform
First CommitSep 2026
AWSome@anurag1,@sahil_rane
Zerops powered Agent-Playground
The Zerops ChallengeAug 2026
Zerops Agent Playground The problem AI coding agents can write a fix in seconds, but the moment they need to touch real infrastructure, most tools either let them run wild or reduce the whole thing to a static demo where nothing actually deploys. There is rarely a middle ground where you can watch an agent work against live infrastructure, see exactly what it wants to change, and decide for yourself whether that change should go out. That gap between "agent writes code" and "agent I can actually trust with my infrastructure" is the real problem here, and it is the one this project is built around. What it does You open the playground, name a session, and pick a stack template. You describe the change you want in plain language, and the agent generates a real code diff alongside a real infrastructure diff. Nothing goes live automatically. You review both diffs side by side, and only when you click approve does the platform reach out to Zerops, package the change, register a new app version, and trigger a live build. Reject it, and nothing touches your infrastructure at all. That approval gate is the core idea: a human stays in the loop for every single change before it reaches a running service. Why Zerops, specifically Zerops is not a deploy target bolted on at the end here, it is what makes the whole loop possible. The backend calls the Zerops REST API directly to create projects, package the agent's generated code and a freshly written zerops.yaml into a deployable bundle, register app versions, and trigger builds, all driven by what the agent produced and what the human just approved seconds earlier. Because Zerops projects spin up fast and exposes the full service lifecycle through a clean API, the gap between "approve this diff" and "watch it running" is seconds, not a CI pipeline someone has to babysit. That immediacy is what makes the review step feel real instead of decorative. The novelty Most agent demos are one shot: prompt in, code out, trust required. This one has a gate in the middle, and everything around that gate is built to actually hold up rather than just look good in a five minute walkthrough. A durable Postgres backed task queue with row level locking means a task in progress survives a process restart instead of vanishing. Live updates stream over Server Sent Events instead of polling, so task status and deploy progress update instantly. Deploys are broken into real stages, packaging, uploading, deploying, done, each one reflecting genuine backend state rather than a spinner that means nothing. Every session carries its own recoverable API key, so a playground survives a cleared browser cache or a different device instead of disappearing. None of this is surface polish, it is the difference between a weekend demo and something you could keep using afterwards. Architecture: Three services, talking to each other in a real request and deploy loop. Frontend: React 19 and Vite, communicating over REST and a live SSE stream for session and task updates. Backend: Fastify on Node.js, handling session and task lifecycle, running the LLM backed coding agent, and driving the entire Zerops deployment flow through Zerops's own REST API. Database: PostgreSQL through Prisma, storing sessions, tasks, and diffs, and doubling as the backing store for a durable task queue. All three run as live Zerops services under one project, defined and deployed through zerops.yaml. Tech stack: React 19, Vite, Fastify, Prisma, PostgreSQL, Server Sent Events, and the Zerops REST API for programmatic project creation, app version registration, and deployment triggering. LLM generation runs through a configurable inference API, with a built in mock fallback so the full review and deploy loop stays testable even without a live model key. The real pain point: Developers do not actually want an agent that deploys on their behalf without asking. They want an agent that shows its work, in real diffs, against real infrastructure, and waits for a yes. That is the gap most agentic coding tools leave open right now, and closing it is the entire premise of this project.