MiniCode
A lightweight terminal coding assistant for local development, with tool calls and review-before-write workflows.
Per-dimension scores and reasoning
Evidence shows permission checks (path and command permission checks), user confirmation flows (approval flows), data flow transparency (tool result preview and disk storage), sensitive data handling (config storage location), dependency security (few dependencies, no known vulnerabilities), external effects (command execution tool), rollback (session resume and fork), source attribution (author list). However, these are descriptive and lack implementation details, and are unverified.
Self-consistency: README, architecture docs, and test files are consistent, but tests have incomplete assertions (e.g., conditional assertions in auto-compact tests). Dependency availability: few dependencies, but no lock file or integrity checks. Failure messages: tests simulate API errors, but no user-visible error handling is shown.
Audience is clear (learning, experimentation, custom tooling), scenarios are clear (terminal coding assistant). Capability boundaries: README lists core capabilities but no explicit limits. Trigger precision: commands and tools are well-defined. Environment fit: multi-language versions exist, but no system requirements.
Information architecture: comprehensive docs (README, USAGE, ARCHITECTURE, etc.). Install notes: installation commands and configuration instructions provided. Naming stability: version 0.1.0, no stability promise. Examples and FAQ: usage guide exists, but no FAQ. Known limitations: not explicitly listed. License: MIT. Versioning/changelog: not provided. Maintenance responsibility: author list clear, but no maintenance policy.
Output usability: terminal UI and tool calling design are reasonable. Marginal value: lightweight alternative with learning value. Cost-benefit: few dependencies, simple installation, but no performance data.
Claim traceability: README feature descriptions align with code structure, but no specific implementation links. Cross-source corroboration: multi-language versions exist, but not cross-verified. Fact-inference separation: docs distinguish feature descriptions and architecture explanations, but inferences are not explicitly marked.
- Test assertions are incomplete, potentially failing to validate functionality.
- No dependency lock file, posing supply chain risk.
- Known limitations are not explicitly listed, users may misunderstand feature boundaries.
- No version changelog, making updates hard to track.
What does this agent do, and when should you use it?
MiniCode is a lightweight terminal coding assistant for local development workflows, with the main repository implemented in TypeScript. Its full-screen terminal UI provides input handling, transcripts, slash-command menus, approval flows, and session operations. A request can run through a model-to-tool-to-model loop that inspects a workspace, invokes tools, and returns a final response in the same terminal session. The project includes local Skills, MCP support, persistent sessions, context compaction, and disk-backed handling for oversized tool output. It runs against local projects from the terminal, while its installer stores model and Anthropic connection settings in a user configuration directory.
MiniCode accepts a request in the terminal, inspects the current workspace, and invokes built-in tools for files, search, editing, command execution, web fetch/search, and clarification prompts. Before file writes, it uses review-before-write behavior plus path and command permission checks; oversized tool results are stored on disk and represented in context by a preview and file path. /init creates .mini-code/ and MINI.md for the current project, while /tools, /skills, /mcp, /status, and /memory expose runtime information; /resume and /compact manage session recovery and context compaction. It finishes by returning a final response in the same terminal session.
- A developer studying Claude Code-like tool loops and terminal interaction architecture who wants a smaller TypeScript implementation to inspect and modify.
- A solo developer working in a local project who wants a terminal assistant to inspect files, search content, run commands, and review edits before writing.
- A developer handling long project conversations who needs persistent sessions plus /resume, rename, fork, and /compact operations.
- A tool builder who wants to discover project-local SKILL.md files or connect MCP tools, resources, and prompts over stdio or remote HTTP.
- A learner who wants to demonstrate the terminal workflow without a model connection by running MINI_CODE_MODEL_MODE=mock.
What are this agent's strengths and limitations?
- Its compact TypeScript implementation exposes a model-to-tool-to-model loop that is suited to study, experimentation, and customization.
- The full-screen TUI includes input history, transcript scrolling, slash-command menus, and approval flows rather than only a single command entry point.
- Long sessions have persistence, resume, rename, fork, auto-compact, context collapse, and snip compact support.
- It combines built-in file, search, edit, command, web, and clarification tools with local Skills and MCP extensibility.
- Installation requires a model name, ANTHROPIC_BASE_URL, and ANTHROPIC_AUTH_TOKEN; the supplied evidence does not document a path for other model providers.
- It requires a local terminal, filesystem access, and npm; the supplied material does not specify a Node.js version.
- Its stated focus is learning, experimentation, and custom tooling, with no production deployment, reliability, or performance guarantees in the supplied evidence.
- Rust, Python, Go, and Java versions are listed as separately linked repositories, not as interchangeable runtimes within this repository.
How do you install or deploy this agent?
From the repository directory, run:
cd mini-code
npm install
npm run install-localThe installer asks for a model name, ANTHROPIC_BASE_URL, and ANTHROPIC_AUTH_TOKEN. It stores configuration in ~/.mini-code/settings.json and ~/.mini-code/mcp.json. MINI_CODE_HOME overrides the configuration directory, and MINI_CODE_BIN_DIR overrides the launcher directory.
How do you use this agent?
After installation, run minicode. For development, run npm run dev; for the offline demonstration mode, run MINI_CODE_MODEL_MODE=mock npm run dev. In the UI, start with /help and use /tools, /skills, /mcp, /status, and /memory as needed; /init scaffolds .mini-code/ and MINI.md in the current project.
How does this agent compare with similar options?
MiniCode describes its workflow and architectural ideas as Claude Code-like, while using a much smaller implementation intended to keep the control flow, tool model, and TUI behavior understandable and extensible.