This post is about coding workflow and Tool use with agents. To set the context, it’s worth a brief reminder on my approach. As I mentioned in another post, the solution I evolved and refined over time is to “chip” at the problem. Solve intermediary goals, evaluate, see what’s left, and repeat until the entire problem is solved. I suppose in a way it’s similar to how diffusion works for image generation: incrementally add and refine until the task is solved.

  %%{init: {'theme':'dark'}}%%
flowchart LR
    A[Plan sub-goal] --> B[ Code the sub-goal]
    B --> C[Evaluate Objective]
    C --> |Goal incomplete| A

  style A fill:#4a9eff,stroke:#2d7ad4,stroke-width:2px,color:#fff
  style C fill:#9b59b6,stroke:#7d3c98,stroke-width:2px,color:#fff
  classDef front fill:#2ecc71,stroke:#27ae60,stroke-width:2px,color:#fff
  class B front

With this in mind, I’ve embraced a philosophy for agentic tools best summarized by Dieter Rams: ‘Weniger Aber Besser’ (Less but Better).

Instead of giving agents raw access to every possible API, I built a layer of Mixers. These are lightweight TypeScript helpers that sit on top of backend services. While a backend service might have a general-purpose API, a Mixer simplifies and polishes that interface so it feels natural for an agent to use.

My Core Mixers:

• findSymbolDefinition(context, symbols) – Navigates LSP definitions.
• findSymbolReference(context, location) – Finds where symbols are used.
• localSearch(query) & webSearch(query) – Retrieval tools.
• executeShellCommand(context, command) – Standard CLI interaction.
• memento(blob) – A way for the agent to “remember” state across steps.

Providing these specialized Mixers yields far better results than letting an agent reinvent recurring action patterns from scratch.

This workflow feels like meta-programming. The agentic planner describes its intended actions in code:

1const results = await localSearch(context, "llm pricing page", 5);
2await memento(results, "#pricing_page_search");
3await setCodingGoal("Find the LLM pricing TSX file and update its title.");

This gives me a “Human-in-the-Loop” checkpoint with three clear options:

1. Approve: Save the plan and let it execute automatically.
2. Refine: Edit the code snippet and add TODOs to tell the agent how to refine its plan. The agent then reworks the plan based on feedback.
3. Partial execution: Part of the plan is good, and it gathers some information required for a better plan. I let that execute, to enrich the Memento so that agent can improve its current plan. For example, the agent might do a webSearch to look up some information needed to crystalize the plan.

The setCodingGoal instruction is used to pass the refined task to the downstream coder agent for the next “chipping” step. This signals that the planning phase is complete, and we move to chipping the next piece of functionality next.

Auto mode: When enabled, a Critic agent reviews the Actor’s (planning agent’s) output and provides feedback replacing the “Human” in the “Human-in-the-Loop”.

Meta-programming gives me the ability to steer the process for complex tasks, and it allows me to provide additonal knowledge and review the code as it gets added to the project, very much like we did code reviews before LLMs.