coding-agent

A senior-engineer-style coding assistant that runs an agentic tool-use loop inside Agentino. Inspired by Claude Code's interaction style; not a literal clone.

What it does

Given a coding task in natural language, the skill:

1. Explores first — reads the relevant files and greps the codebase before proposing changes.
2. Plans non-trivial work — sketches a 2-5 bullet plan before editing.
3. Reads before writing — always loads the current contents before file-write so the runtime can capture a unified diff for every change.
4. Edits minimally — touches only what's needed, no speculative refactors.
5. Delegates narrow sub-tasks when it helps — via the virtual spawn_subagent tool, a fresh LLM worker picks up self-contained work (audit a module, write edge-case tests, analyse a file) with its own iteration budget and returns a focused string the parent integrates.
6. Verifies before claiming done — runs tests, linters, or the code itself via skill:run-shell.
7. Reports with diffs — final answer summarises what changed, how it was verified, and the unified diff of each touched file (≤5 lines narrative + compact diffs).

It delegates all side effects to other installed skills via Agentino's ToolUseManager. Every file write, grep, or shell execution goes through the respective skill's own sandbox + confirm-gate. Subagent recursion is bounded at depth 1 and total spawns are capped by the max_subagents input (default 3).

How it differs from Claude Code

Honest disclosure: Claude Code is a closed commercial product (Anthropic). This skill approximates the UX using Agentino's open toolset. Differences (v1.1.0 closes two gaps from v1.0.0):

	Claude Code	coding-agent v1.1.0
Editor diff view	✅ real-time inline	✅ textual unified-diff in the final answer + output.diffs[] (post-write, not pre-write — v1.1.0)
Task / sub-agent spawn	✅	✅ virtual spawn_subagent tool with bounded recursion (depth 1, budget capped — v1.1.0)
Persistent project memory across invocations	✅	⚠️ partial via agentino chat --session
Hook system / slash commands	✅	❌ (harness feature, not replicable inside a skill)
MCP server connections	✅	✅ via agentino mcp connect
Tool catalog	curated built-in set	every skill in user's Agentino registry
Model choice	Claude only (Opus/Sonnet/Haiku)	any provider Agentino supports

For the 90% of coding tasks (read, edit, test, report, delegate narrow sub-tasks, see what changed), the skill does the same shape.

How the v1.1.0 additions work

Diff view — the system prompt tells the LLM to skill:file-read a file before skill:file-writeing it. The runtime records the "before" content in memory, then on every file-write tool call computes a unified diff (max 40 lines, auto-truncated for giant rewrites) and appends it to output.diffs. The LLM is also instructed to summarise the diff in its final answer. So you see what changed both in the structured JSON (for programmatic callers) and in the text report (for human readers).

Subagent spawn — a virtual tool spawn_subagent is injected into the catalog at runtime. When the parent LLM calls it with {sub_task, max_iterations, system_prompt}, the skill runs a fresh ToolUseManager with its own short system prompt, separate call log, and independent iteration budget. Subagents cannot themselves spawn subagents (depth is capped at 1 to prevent unbounded recursion). The parent CLI caps total subagent spawns at max_subagents (default 3). Results come back as strings that the parent integrates into its own reasoning. Each subagent's run is recorded in output.subagent_calls[].

Usage

# Install from the marketplace
agentino marketplace install agentino-os/agentino-skill-coding-agent

# Run it
agentino skill exec coding-agent -i task="add a --verbose flag to the CLI in cli/main.py, default False"

# Cap iterations for cost control
agentino skill exec coding-agent -i task="..." -i max_iterations=5

# Override the system prompt (most users should leave the default)
agentino skill exec coding-agent -i task="..." -i system_prompt="You are ..."

# Force a specific model
agentino skill exec coding-agent -i task="..." -i model="claude-sonnet-4-5-20250929"

Output shape

{
  "answer": "…final assistant text including a human-readable diff summary…",
  "iterations": 4,
  "tool_calls": [
    {"name": "skill:grep-search", "arguments": {...}, "elapsed_s": 0.2, "error": null},
    {"name": "skill:file-read",   "arguments": {...}, "elapsed_s": 0.1, "error": null},
    {"name": "skill:file-write",  "arguments": {...}, "elapsed_s": 0.1, "error": null},
    {"name": "skill:run-shell",   "arguments": {"cmd": "pytest -q"}, "elapsed_s": 12.4, "error": null}
  ],
  "subagent_calls": [
    {"task": "write 3 edge-case tests for normalise_email()", "answer": "…", "iterations": 3, "elapsed_s": 18.2}
  ],
  "diffs": [
    {"path": "src/users.py", "diff": "--- a/src/users.py\n+++ b/src/users.py\n@@ -12,6 +12,11 @@\n+    if not email:\n+        raise ValueError(...)\n ..."}
  ],
  "tools_available": 102,
  "model_used": "claude-sonnet-4-5-20250929",
  "total_elapsed_s": 64.0
}

Security posture

• The outer skill itself runs at sandbox_level: none because it only orchestrates (imports Agentino, initialises the kernel, passes strings to the LLM router). It does NOT open files or spawn processes directly.
• Every delegated tool call runs inside its own skill's sandbox — file-write stays process, run-shell asks for confirm=true on destructive operations, the AST scanner still gates any auto-generated skill.
• timeout_s: 600 caps the full loop at 10 minutes. max_iterations (default 10) caps the LLM↔tool round-trips.
• network_access: true because the LLM call goes over the internet (unless you point Agentino at an Ollama local model).

Dependencies

• Agentino >= 1.2.0-rc.2.
• A configured LLM provider (agentino config set-key anthropic <key> recommended — Claude models respond best to the tool-use format this skill uses).
• structlog (a core Agentino dependency, always present — the AST scanner flags it as external but it ships with every Agentino install).

Caveats

1. Closer to Claude Code now, but still not a replacement. v1.1.0 closes the diff-view and subagent gaps. What's still missing: real-time diff confirmation before the write lands (ours is post-write), true parallel subagents (ours are serialised), hook system, slash commands. If you need those, use Claude Code. Use this skill when you want most of that behaviour from inside Agentino.
2. Tool catalog is whatever you have installed. If your registry has 10 skills, the agent sees 10 tools + spawn_subagent. Install the usual suspects first: file-read, file-write, grep-search, run-shell, code-security-scanner, git-diff-review.
3. Kernel re-initialisation is slow (~1-2s) on the first call because the skill boots its own lightweight kernel. Each spawn_subagent call reuses the same kernel, so the cost is paid once.
4. Subagent recursion is bounded at depth 1. A subagent that tries to call spawn_subagent gets a budget-exhausted message. This is intentional — prevents cost runaway from accidental infinite delegation.

License

MIT — by Stefano D'Agostino. See the main Agentino repo.