# Built a mini-AWS with Claude for Claude — retained record

> Retained reddit record from reddit:ClaudeAI.

Canonical: https://highsignal.app/data/records/e4e6e0a8932edc86

[← sources](https://highsignal.app/data)


source: [reddit](https://highsignal.app/data/reddit) (reddit:ClaudeAI)  published 2026-10-22 21:01 ingested 2026-10-23 02:38

[original source ↗](https://www.reddit.com/r/ClaudeAI/comments/1xcup8x/built_a_miniaws_with_claude_for_claude/)

## retained text



```
Hey folks, I want to share what I've been building with Claude Code, and the workflow that made it possible.



To be upfront: the first part of this post is about the product, and the second part is a tech-heavy share of what I learned. Feel free to pick part you wanna read.

------

# Part 1: The product

The product is Pilely.

The problem: a lot of non-coders now use Claude to write a website, then get stuck at putting it online. Hosting, domains, login, a database, payments. Every piece is a new account and docs written for engineers. I realized the issue isn't the AI. Today's infra is built for humans, and there's no single entry point an AI can start from and set everything up on its own.

So Pilely lets non-coders use their own Claude (or another AI) to build a website and put it online, with login, a database, email and Stripe payments if they need them. 

There's no new app or new website to learn. Everything happens in your Claude Code. Under the hood, each service has a plain-text README written for agents, and Claude reads those to set everything up.


It's free to try. No card needed, and you only pay for traffic once people use your site. Paste this into Claude Code:

`curl [https://pam.pilely.app](https://pam.pilely.app) and ask Pam to help me build my first app.`



Website: [https://pilely.ai](https://pilely.ai)



# Part 2: Learnings (tech background helpful)

I was an infra engineer at Instagram. I know what good infrastructure looks like: clean service boundaries, clear access control, careful deploys. But building a whole platform like that alone, by hand, would have taken me years.



Pilely is basically a mini-AWS for Claude (and other AIs like ChatGPT) to use, so non-coders never have to deal with any of it. With Claude Code I built it, about a dozen small services, in roughly 2 months, and the quality is where I'd want it to be.



Early on, I'd just discuss a task with Claude in the monorepo, ask it to write a task file, and review it. After a while I stopped reviewing the task files, because it took too much of my time. Then the complexity grew, and managing it became the real problem. Here are a few things I explored and learned.



## task_flow



The key was a personal skill I wrote called task\_flow. It has a few stages:



1. Research. I write a task file describing what I want, never how. A research agent turns it into open questions about the codebase and sends helper agents to dig into them in parallel. This stops the plan from being built on wrong assumptions.



2. Planning. A planning agent breaks the task into a tree of small, concrete pieces, each with what "done" means. This might be the most interesting part: I explicitly define the tree structure in YAML, so it can be verified by a script.



3. Planning verification. Separate, fresh verifier agents judge the plan piece by piece and return PASS or FAIL. If it fails, the planner revises and new verifiers check again. This stage saved me the most time: catching a bad plan is far cheaper than catching bad code.



4. Implementing. An implementing agent hands each piece to its own fresh worker agent, proves it works with local tests, and commits piece by piece.



5. Code review. A fresh reviewer agent reviews each round of the diff, with helpers covering different areas. The loop continues until only minor findings are left.



6. Deployment. After the PR merges, a deployment agent applies the production changes (migrations, secrets, config) and writes a push request into a DB. We don't push per task. A pusher agent runs every N minutes, collects all new requests and ships them together.



Each stage has its own stage agent plus helpers.

The whole point is: writing code is easy and what CC is good at. But planning/direction wrong is fatal. So I'd rather spend more time and tokens on that first to make sure we are on the right rail before kick off the engine.

Agents never talk to each other directly. Each task flow has a flow_server, and every agent reads and writes through its endpoints. The flow_server holds the central state of the whole flow, and everyone reads from it. I'm not sure how best to describe it, but this changed the quality of my coding with Claude completely.



Another lesson: when writing an agent profile, if a check can be a fixed script, make it a script. It reduces drift a lot.



With this setup, I often have around 10 tasks running at once, each in its own worktree in the monorepo, and they do really well.


## Let Claude test its own product



Once the infra and the agent instructions were ready, I needed to test whether everything actually worked. For example: can a real user with Claude build a real website smoothly?



I discussed it with Claude, and it came up with the idea of launching a separate Claude Code cli instance as a process where an agent plays the user, with everything isolated: a fresh folder, a fresh CC instance, and a "user" agent that only talks, like a real non-coder would. An orchestrator watches every stage and writes a report with proposed fixes.



So most nights before bed, I launch 3 or 4 of these tests. In the morning I know which parts broke, and I fix or improve them.



Happy to go deeper on any of this, and feedback on the workflow or on Pilely is very welcome.
```



document fetched 2026-10-23 00:23 · canonical https://reddit.com/r/ClaudeAI/comments/1xcup8x/built_a_miniaws_with_claude_for_claude
