Putting it all together

This is the last lesson in 4RGED Learn — and the most practical one. Earlier pages explained pieces (models, context, tools, review). This page shows one complete job from "I need this small thing" to "I merged it and I'd do it again tomorrow."

You are not learning more theory here. You are learning a repeatable loop: describe the outcome, let the agent work in your repo, review what it proposes, prove it with tests, then ship when you are satisfied.

What this page is for

Who this page is for

The loop in four moves

Every agent task — feature, fix, or refactor — fits the same rhythm:

That is the whole product in one table. The sections below walk through one example so you see where each earlier Learn lesson fits — without reading them all first.

One story end-to-end

Imagine a small, real task: add a discount code field on checkout — validate the code, update the total, show an inline error when invalid. Nothing huge; something you could review in one PR.

That single story touches every habit in this track:

You do not read every lesson before starting. Come back when that phase bites you.

Example first message

Paste something like this into 4RGE Desktop and edit for your repo:

Add a discount code field on checkout.
 
Done when:
- Invalid code shows inline error (no page crash)
- Valid code lowers total before tax; total never below zero
- Match existing checkout UI patterns in @checkout/OrderSummary.tsx
 
Build in two slices: (1) pricing validation + tests, (2) UI wiring.
Run: pnpm test apps/web -- checkout
Do not change the task list API or database schema.

That one message covers outcome, acceptance, anchors, slices, and verify — the habits from Developing features and Working with agents.

Step by step

A practical sequence for the checkout example (or any small feature):

If step 8 fails, switch to a debugging brief — symptom, repro, evidence — not "try again harder." See Finding and fixing bugs.

If the thread wanders, revert and restart with a tighter spec — faster than ten follow-ups — Working with agents.

What success looks like

You nailed the loop when all of this is true:

Pick the right surface

Same loop; different where the work runs:

Org models, budgets, and plugins apply on all surfaces — Customizing agents.

When it clicks

Agents stop feeling like magic when this becomes muscle memory:

1. You write "done" — acceptance + one verify command.
2. You review every diff — same bar as human code.
3. You split big work — spec → plan → slices → verify.
4. You reset bad runs — revert beats arguing with a lost thread.
5. You capture learnings in the repo — next run starts smarter.

That is infrastructure, not a one-off demo. Repeat on the next small task; scope up only when the loop feels boring.

The full Learn path

Use this map when you need depth on one topic:

Product docs go deeper: Agent overview, Prompting, Projects, Dashboard.

Habits that work

1. Pick the smallest real task — one PR, not a quarter roadmap.
2. Explore before edit when the area is unfamiliar.
3. Name tests in the first message — agent and you agree on green.
4. Review as you go — not only at the end.
5. Hand off long work to cloud with the same mini-spec.
6. Teach the repo — update AGENTS.md when the same correction twice.

Where to go next

Questions about putting it all together?