yact

GitHub

YACT - Yet Another Coding Tool

Minimal, responsive, transparent LLM coding assistant

Design principles

Comparison to Mainstream Coding Agents

YACT differs from mainstream coding assistants, like Cline, Cursor and Copilot, in the sense that it not aims to be a complete, automated coding suite, rather be a Swiss army knife for LLM assisted coding. This is why it is called a “Coding Tool” rather than a “Coding Agent”.

RAG vs Prompt Stuffing

Mainstream coding agents typically use the Retrieval Augmented Generation (RAG) approach. This means, that the LLM decides what files it needs to read to complete the given task, and uses the agent’s file reading tool to retrieve the necessary file contents.

YACT uses the prompt stuffing approach. The developer uses YACT’s explicit read command to add files to the task context. The content of these files is appended to the prompt. The LLM can not initiate file reading.

Proactive vs Reactive

Mainstream coding agents typically utilize a chat interface. Once the developer sends an initial prompt, they are free to proactively explore the codebase, run commands, edit files (with permission), while sending multiple API calls to the LLM.

YACT, on the other hand, is reactive. The developer needs to select the files needed for the task, and explicitly append them to the prompt with the read command. Once the prompt is ready, a single API call will be made to the LLM. Depending on the task, the LLM will respond in human language, or with generated code, that will be inserted into the code base by YACT.

Tool Usage vs Code Blocks

The earliest LLMs that were available through API had a really strict output token limit, as low as 4000 tokens, which meant, that only 100 to 200 lines of codes could be generated in a single API call. To overcome this restriction agent developers introduced file editing tools, to enable their agents to incrementally edit code files.

Today, typical output token limits are around 64K to 128K, which, with adequate clean coding practices, is plenty to generate multiple complete source files. Exploiting this “late comer’s advantage”, YACT always generates complete source files, making its LLM interface far simpler than most agents. This approach also enables YACT to aggressively compact its context, keeping API calls responsive, and cheap.

Comparison

| | Cline / Cursor / Copilot | YACT | |————————–|————————————————————————————————|————————————————————————————————————————————-| | Interface Type | Chat | CLI | | Generation method | Retrieval Augumented Generation (RAG) | Prompt Stuffing | | LLM interface complexity | Complex | Simple | | Model Selection | Larger Models | Works with a larger selection of models, down to 7b parameters. | | MCP usage | Yes | No | | API Cost | Up to $50 per day | Up to $2 per day | | Vibe Coding Capable | Yes | No | | File size limitations | No limitation, however, they tend to be less effective on large source files. | Editable file sizes are limited by the LLMs output token limit. Limiting file sizes to a few hundred lines of code is recomended. | | Coding standards | No official recomendations. | Strict clean coding principles are recomended. |

Modes

YACT uses Ask / Plan / Act / Bash modes. The plan and act modes can be familiar for users of competing tools. The plan mode creates a step-by-step implementation plan for a given task, which can then be implemented using act mode. In ask mode you can ask questions about your code base without interfering with coding tasks. In bash mode you can generate shell commands for a task.

Installation

Download the latest binary for your operating system from the GitHub releases page.

Available binaries:

For example, to download and install on Linux:

cd /tmp
wget https://github.com/agabor/yact/releases/download/v0.0.0/yact-linux-amd64
chmod +x yact-linux-amd64
sudo mv yact-linux-amd64 /usr/local/bin/y

On macOS:

cd /tmp
curl -L -o yact-darwin-amd64 https://github.com/agabor/yact/releases/download/v0.0.0/yact-darwin-amd64
chmod +x yact-darwin-amd64
sudo mv yact-darwin-amd64 /usr/local/bin/y

On Windows, download the yact-windows-amd64.exe file and place it in a directory that’s in your PATH, or run it directly from where you download it.

Quick Start

Before using y, configure your Claude API key:

y config anthropic_api_key YOUR_API_KEY

You can verify your configuration at any time:

y config

How It Works

YACT stores the current task in a plain text file: .yact/prompt.txt in your project directory. This file has two sections separated by a ========== line:

You build up a task by adding files with y read, writing your prompt into .yact/prompt.txt, then running one of the mode commands (ask, plan, act, bash). Each of these commands makes exactly one API call.

Commands

Start a New Task

Create a fresh, empty task context:

y new

Add Files to the Context

Attach files so the AI can reference them:

y read main.go
y read "commands/*.go"

Glob patterns are supported. Directories are skipped, and files already in the context are not added twice.

Set the Prompt

Set the task prompt in .yact/prompt.txt directly from the CLI:

y prompt "implement the Foo feature"

Ask Questions

Write your question into .yact/prompt.txt, then run:

y ask

You can also pass the question inline as an optional argument, which replaces the prompt in .yact/prompt.txt before the API call:

y ask "is Foo buggy?"

The response is printed to the terminal. Your task context is not modified.

Create a Plan

Write your task into .yact/prompt.txt, then run:

y plan

You can also pass the task inline as an optional argument, which replaces the prompt in .yact/prompt.txt before the API call:

y plan "add authentication"

The generated plan is printed and also replaces the prompt in .yact/prompt.txt, so you can follow it up directly with y act.

Generate Code

Write your task (or generate a plan) into .yact/prompt.txt, then run:

y act

You can also pass the task inline as an optional argument, which replaces the prompt in .yact/prompt.txt before the API call:

y act "implement Foo"

The AI responds with complete source files, which YACT writes directly to your filesystem. Newly created files are automatically added to the task context. Use --no-write to print the response instead of writing files:

y -n act

Generate Bash Commands

Write your task into .yact/prompt.txt, then run:

y bash

You can also pass the task inline as an optional argument, which replaces the prompt in .yact/prompt.txt before the API call:

y bash "find all TODO comments in Go files"

The response is printed to the terminal and logged to the buffer. Your task context is not modified.

Show the Buffer

Output the content of .yact/buffer.txt, the log of the last command’s output:

y buffer

Edit a Line Range

Modify a specific line range in a file with a prompt, preserving indentation:

y snip main.go 10 20 "simplify this loop"

Index the Project

Scan the project directory and create or update .yact/index.csv, which maps every file to a short AI-generated description:

y index

Hidden files and common directories like .git, node_modules, dist and build are excluded. Deleted files are removed from the index, and existing descriptions are preserved.

Discover Relevant Files

Automatically populate the task context based on the prompt in .yact/prompt.txt:

y context

This uses the project index in two ways:

Run y index first, so the index is up to date.

Global Flags

-h, --help        Show help message
-t, --think       Enable Claude's extended thinking mode
-n, --no-write    Do not write files, print response instead
-f, --fable       Use Claude Fable model
-o, --opus        Use Claude Opus model
-s, --sonnet      Use Claude Sonnet model
    --haiku       Use Claude Haiku model

Flags come before the command:

y -t act
y --think --sonnet plan
y -o ask

Model flags override the configured model for a single invocation. With --think, the model’s reasoning is printed before the response.

Configuration

View current settings:

y config

Set configuration values:

y config anthropic_api_key your_key_here
y config claude_model sonnet
y config max_tokens 32000
y config think_budget 16000

Available configuration keys:

System Prompts

Each mode uses a system prompt loaded from ~/.yact/systemprompts/:

These files must exist for the corresponding command to work, and you are free to tailor them to your workflow.

Cost Tracking

Every API call prints the model used, call duration, input and output token counts, and the estimated cost in dollars. A warning is shown if the response hit the output token limit and may be incomplete.

Help

Display command reference:

y help
y --help
y -h

Storage

Global settings are stored in ~/.yact/:

Per-project state is stored in .yact/ inside your project directory:

Troubleshooting

“Claude API key not configured”

“No files found matching pattern”

“no task prompt found”

“Error loading … prompt”

API errors