lac agent as Your API Dev Loop

Three windows, one job

For a long time my API dev routine looked like this: VS Code open on the left, a terminal running the server in the background, and Postman (or Insomnia, or curl buried in my shell history) somewhere on the right. Every time I made a code change I'd flip windows, re-fire the request, check the response, flip back. It's not a disaster but it's friction — the kind that adds up and breaks your focus.

lac agent doesn't fix this by being a fancy IDE. It fixes it by keeping everything — code edits, HTTP requests, task tracking, diffs — inside one terminal session. Once I started leaning into all four of those features together, the window-flipping mostly stopped.

Starting a session

If you don't have lac-cli yet, grab it with:

pip install lac-cli

or the one-liner:

curl -fsSL https://lacai.io/install.sh | bash

Then from inside your project root:

lac agent

On the first run it'll ask which provider you want (Claude, OpenAI, Ollama — your choice). After that it reads your project files and you're in. If you've run it before, it'll also pull in whatever you've stored in .lac-memory.json — so it already knows your stack, your conventions, your folder structure. You don't re-explain yourself every session.

The HTTP request runner

This is the part that killed Postman for me during development. Once your dev server is running, you can tell lac agent to make HTTP requests directly from the conversation:

POST /api/users with body { "name": "Ada", "email": "ada@example.com" }

It fires the request, shows you the response status, headers, and body right in the terminal. No tab switching, no copying endpoints into a GUI tool.

What makes it useful beyond raw convenience is that the agent sees both sides — the code it just wrote and the response that came back. If the API returns a 422 with a validation error, you don't have to paste that error back into the chat. It's already there. The agent can read the response, figure out what's wrong, and propose a fix in the same turn.

That tight feedback loop — write code, run request, see response, fix code — used to require at least two context switches. Now it's one conversation.

Task tracking that actually stays out of the way

Bigger features tend to have a list of sub-tasks: add the endpoint, write the validation, hook up the database query, handle the error cases, write a quick test. It's easy to lose track of where you are mid-session, especially if you went down a rabbit hole fixing something unexpected.

lac agent has a built-in task tracker. You can give it a list at the start:

Tasks for this session:
1. Add POST /api/posts endpoint
2. Validate title and body fields
3. Save to database
4. Return 201 with the created post
5. Handle duplicate slug error

As it works through each one it marks them off. You can ask what's left? at any point and it'll give you a clean status. It's not a project management system — it's just a lightweight way to keep a session focused without keeping a sticky note next to your keyboard.

Diff preview before anything gets written

This is the part I'd recommend to anyone who felt nervous about an AI writing directly to their files. Before lac agent commits any change it shows you a diff — what's being added, what's being removed, line by line. You confirm, then it writes.

You can also step back. If you confirmed a change and immediately realize it broke something, /undo reverts it. The diff preview and undo together mean you're never more than one step away from clean state. It removes the anxiety of letting the agent touch real files.

Combined with the HTTP runner, the workflow becomes: agent proposes a change, you review the diff, confirm, it writes the file, you ask it to fire the request, you see the result. All in one window.

PlanMode for bigger changes

If you're about to do something non-trivial — restructuring a controller, swapping out an auth strategy, adding a whole new resource — it's worth switching into PlanMode first:

/plan refactor the auth middleware to use refresh tokens

The agent lays out what it intends to do across which files before touching anything. You can push back, adjust the scope, or say go ahead. It's the difference between letting it charge ahead and actually understanding what's about to happen to your codebase.

Project memory keeps context across days

One thing worth mentioning if you haven't used lac agent before: the .lac-memory.json file in your project root is where it stores persistent context. Things like your preferred error handling pattern, which ORM you're using, what the existing route structure looks like. You can also manually edit it if you want to add conventions the agent should always respect.

This means tomorrow when you run lac agent again, you're not starting from scratch. It remembers the project. That matters a lot when you're building something over multiple sessions.

A practical starting point

If you want to try the HTTP runner specifically, the fastest way is:

1. Start your dev server in a separate terminal tab
2. Run lac agent in your project root
3. Ask it to write an endpoint
4. Once it's done, say "send a POST to /your-endpoint with test data"
5. Watch the response appear inline

If the response looks wrong, just say so. The agent has the code and the response in view at the same time. That's the whole point — context stays in one place instead of being split across tools.

You can find more on lac-cli over at lacai.io/lac-cli. It's MIT licensed, free, and installs in about thirty seconds.