Agentic Coding

Bad code is the most expensive it's ever been.

While agentic coding is powerful, it introduces new engineering challenges around control, reliability, and maintainability.

The goal is not to make agents write more code; it is to make them produce code that stays easy to change.

So why does this matter?

Agentic engineering starts from a simple observation: large language models are no longer just autocomplete systems. In many workflows, they behave more like interpreters. The "program" is not only code. It is the whole input you give the model:

• instructions
• constraints
• files, examples
• tools
• state
• environment

In that sense, the context window becomes the new execution surface.

In an agentic system, some behavior is still encoded in code, but a meaningful part of the system is produced at runtime from language, context, and tool use. The practical question becomes "what capability do we give the agent, and how do we shape its judgment?”

These systems are stochastic. They can be useful, capable, and often impressive, but they are not inherently verifiable in the way ordinary programs are. The core research problem in this paradigm is verifiability.

This is why prompting alone is not enough. You need:

• orchestration
• evaluation
• interfaces
• tool design
• environment control
• testable boundaries
• reviewable outputs

Hence, setup matters a lot. The problem this guide is trying to address is how we can design reliable systems with non-deterministic intelligence.

Software 3.0

What’s described above is sometimes described as Software 3.0: software is increasingly specified in natural language and executed through models. The agent carries packaged intelligence and adapts its actions to the local environment. Instead of building a fixed application for every narrow workflow, you can often describe the task and get a bespoke solution for that situation.

Here is what the division of tasks is likely to look like in Software 3.0:

1. Deterministic (old school) software serves as infrastructure, boundary, and tool.

   This is so that we can manage persistence, permissions, computation, integration, testing, and enforcement.

2. The neural network handles interpretation, synthesis, and adaptation.

This is why agentic engineering is not mainly about making software generation faster. Some of the value is speed, but the deeper change is that new kinds of systems become possible. Agents can inspect a codebase, form a plan, use tools, recover from intermediate failures, and adapt their approach to the environment. That is qualitatively different from ordinary automation.

Coding tools

Kiro

Tool-specific notes for the Kiro CLI, checked against kiro-cli 2.8.1 in September 2026. Several items are adapted from the tips the CLI itself displays. Commands and flags change between releases, so confirm them with kiro-cli chat --help.

Productivity:

• You can type the next message while the agent is still working; messages queue automatically (Activity Tray: Ctrl+X).
• Ctrl+R for reverse history search across sessions
• @ in input for async file search with autocomplete
• /spawn to run parallel agent sessions

Get better results:

• Create custom agents (.kiro/agents/my-agent.json) with focused prompts, restricted tools, and pre-loaded context files
• Use resources in agent config to auto-load relevant files into context
• Use skill:// resources for on-demand loading of large reference docs
• Use hooks (agentSpawn, userPromptSubmit) to inject dynamic context (git status, env info)
• Index project docs in a knowledge base so the agent can search them semantically, for example by asking it to add ./docs to knowledge.

Trust & speed:

• --trust-tools=<names> pre-approves only the listed tools. Keep the list as narrow as the task allows, e.g. --trust-tools=fs_read for a read-only review. Avoid --trust-all-tools (-a) outside a disposable sandbox: it lets the agent run any shell command and write any file without asking.
• allowedTools in an agent config makes auto-approval permanent for that agent, so apply the same least-privilege rule there.
• chat.enableThinking true for complex reasoning tasks

Automation:

• Headless mode: kiro-cli chat --no-interactive "<prompt>" runs one prompt without expecting user input. An unattended run cannot answer approval prompts, so grant only the tools the task needs, and run anything that writes files or executes commands in a throwaway checkout or CI container.
• Save/load sessions: /chat save and /chat load for resumable work
• --resume (-r) resumes the most recent conversation from the current directory.

Code intelligence:

• Run /code init once per project to enable LSP features
• Use /code overview to quickly understand unfamiliar codebases
• AST pattern search/rewrite for structural refactoring across files