Building on your own

Start with one responsibility you can explain: an order awaiting approval, an import job, a watchlist or an agent’s tool request. Give it a state owner, a small set of operations and a clear definition of success.

Septa gives your coding agent a precise implementation surface. Your job is to make the intent and boundaries clear, then inspect the behaviour and evidence it produces.

Give the agent a bounded assignment

This is a task brief, not executable code:

Build a small order-approval service. An order can be submitted, approved or rejected. Keep the decision state in one durable actor. Make invalid transitions explicit. List the effects and authority needed by each operation. Show tests for the accepted and refused transitions, and explain what survives a process restart.

The brief names an outcome and constraints. It leaves implementation work to the agent while giving you specific things to review.

Inspect four things first

1. Ownership: identify the actor that owns the order’s state. A second component should request a change through its contract.
2. Operations: read the input and outcome types. Check that your business rules are represented, including refusal cases.
3. Reach: inspect the effects and capabilities. An approval service does not need authority to perform unrelated account administration.
4. Continuity: inspect the durable state before and after reopening. Treat external calls as a separate integration check.

You can read and edit the Rust directly. The system model helps you decide where that attention is most valuable.

Keep the first system small

Actor boundaries can live within one runtime. You can organise domain responsibilities without committing to microservices, multiple deployment pipelines or a distributed topology.

Extract a library when logic has a useful reusable contract. You might begin with pricing rules, validation or a domain vocabulary. The library tutorial shows the separate consumer that exercises it.

A good first session

Run the durable counter, then change one business rule in a small example with your agent. Use review an agent’s change before broadening the task.

The aim is a first result you understand. Faster code production is valuable when you can still explain what owns the state, what may happen and why the result is acceptable.