GitHub - dvcoolarun/taste-ai: taste - Zero-config session-taste packer for AI agents

Zero-config. Auto-learns. Just works.

97% smaller context · Auto-learns your style · Works with any agent
_{Compresses AI agent context from 56K tokens to 1.9K tokens. Learns your coding patterns from git history and session logs. Results vary by project size and session history.}

Install

The most effort taste will ever ask of you:

One-Line Install (Recommended)

curl -fsSL https://raw.githubusercontent.com/dvcoolarun/taste-ai/main/install.sh | bash

Manual Install

git clone https://github.com/dvcoolarun/taste-ai.git
cd taste-ai
chmod +x taste
cp taste ~/.local/bin/

Verify Installation

Quick Start

# 1. Navigate to any project
cd ~/my-project

# 2. Generate context
taste

# 3. Start your agent
opencode .

How It Works

┌─────────────────────────────────────────────────────────┐
│              Data Collection                            │
│  - Last 3-5 session logs                               │
│  - Last 3-5 prompt logs                                │
│  - Git diffs (last 3-5 commits)                        │
│  - Current taste config                                │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│              Summary Creation                           │
│  - Compact format (18KB typical)                       │
│  - Token-efficient structure                           │
│  - Essential information only                          │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│              Agent Analysis                             │
│  - Calls opencode or claude                            │
│  - Uses pattern extraction prompt                      │
│  - Returns structured patterns                         │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│              Pattern Extraction                         │
│  - NAMING conventions → TASTE.md                       │
│  - ARCHITECTURE patterns → TASTE.md                    │
│  - IMPORTS style → TASTE.md                            │
│  - ERROR_HANDLING patterns → TASTE.md                  │
│  - STYLE preferences → TASTE.md                        │
│  - BANNED_PATTERNS → .agent-taste.json                 │
└─────────────────────────────────────────────────────────┘
                           │
                           ▼
┌─────────────────────────────────────────────────────────┐
│              Auto-Update                                │
│  - Positive patterns → TASTE.md                        │
│  - Banned patterns → .agent-taste.json                 │
│  - Preserve existing patterns                          │
│  - Avoid duplicates                                    │
└─────────────────────────────────────────────────────────┘

Lazy, not negligent: validation, error handling, security, and accessibility patterns are never skipped.

Pattern Learning

Pattern Categories

Category	What It Learns	Output Location
NAMING	Function naming conventions (snake_case, camelCase, etc.)	TASTE.md
ARCHITECTURE	Project structure patterns, dependency management	TASTE.md
IMPORTS	Import style, ordering, lazy vs eager imports	TASTE.md
ERROR_HANDLING	Try/catch patterns, error propagation	TASTE.md
STYLE	Code formatting, function length, comments	TASTE.md
BANNED_PATTERNS	What NOT to do, with reasons	.agent-taste.json

Banned Patterns

taste learns both positive patterns (what to do) and negative patterns (what NOT to do). Banned patterns are extracted from user corrections, past mistakes, and feedback.

Example banned patterns:

{
  "banned_patterns": [
    "--single-process_Chromium_flag_on_macOS (reason: causes crashes, documented failure)",
    "hardcoding_connection_URLs_or_env_specific_values (reason: caused 'Queue service unavailable' failure)",
    "jumping_to_implementation_before_design_alignment (reason: wasted work when pricing model wasn't confirmed)",
    "removing_comments_during_code_rewrites (reason: user explicitly called out and expects preservation)",
    "using_browser_only_Node_APIs_in_subprocess (reason: ErrorEvent caused ReferenceError)"
  ]
}

Why banned patterns matter:

Specific - Not generic ("don't use classes") but concrete ("don't use --single_process_Chrome_flag")
Actionable - Clear reasons that explain WHY it's banned
Learned from mistakes - "was replaced with page.setContent" shows historical context
Platform-aware - "crashes on macOS" shows environment-specific knowledge

You know the problem. You start an AI agent session. It reads your entire project: session logs, git diffs, READMEs, config files. It writes code that doesn't match your style. It wastes tokens and produces generic, bloated code.

taste puts a stop to that. It learns your patterns. It compresses your context. It makes your agents write code like you do.

Before / after

You ask for a rate limiter. Your agent reads 56K tokens of context, installs a library, writes a generic implementation, and asks about your Redis setup.

With taste:

taste
# Creates .session-doc.md with 1.9K tokens
# Agent reads your patterns, writes code your way

More examples in examples/.

Numbers

Five metrics, one goal: make your agents write better code with less context.

Metric	Without taste	With taste	Improvement
Token usage	56,000	1,950	97% reduction
Context quality	Generic	Project-specific	Better
Pattern learning	Manual	Automatic	Zero-config
Agent support	Single	Multiple	3+ agents
Setup time	Hours	Seconds	Instant

97% smaller context, auto-learns your style, and works with any agent. Every pattern taste learns is marked in the code with confidence scores. Reproduce it yourself: run taste learn in any project. Method and raw numbers: benchmarks/. Real-world examples: examples/.

That is the byproduct, not the pitch. These are average numbers, and they vary by project. Larger projects with more session history see better compression. Smaller projects with less history see smaller savings. And all of this is iterative: each time you run taste learn, it learns more patterns, which makes the next compression better. The rule was never "fewest tokens." It is: learn only what the project needs, and never skip validation, error handling, security, or accessibility. The context ends up small because it is necessary, not trimmed, and that is the part that stays useful. Better code quality is a side effect of learning your style, and that is the part that matters.

Usage

Pack Context

# In any project directory
taste

# Generates .session-doc.md with compressed context

Learn Patterns

# Analyze last 3 sessions and learn patterns
taste learn

# Analyze last 5 sessions
taste learn --depth 5

# Show patterns without updating files
taste learn --dry-run

Initialize Taste Config

# Create default .agent-taste.json
taste init

Show Current Config

# Display current taste configuration
taste show

Commands

Command	What it does
`taste`	Pack session context into `.session-doc.md`
`taste pack [file]`	Pack to specific output file
`taste init`	Create default `.agent-taste.json`
`taste show`	Show current taste config
`taste learn`	Learn patterns from recent sessions (agent-assisted)
`taste help`	Show help

Learn Options

Flag	Description
`--depth N`	Analyze last N sessions (default: 3)
`--model MODEL`	Model to use for analysis (overrides `TASTE_MODEL`)
`--dry-run`	Show patterns without updating files

Integration

With opencode

# Before starting opencode
taste

# Feed to opencode
opencode .

With Claude Code

# Before starting claude
taste

# Feed to claude
claude .

With Any Agent

# Generate context
taste

# Agent reads .session-doc.md automatically

Example Output

`taste` Output

# TASTE BOUNDARIES
Source: `.agent-taste.json`
```json
{
  "flavor": "Functional TypeScript, strict types, zero dependencies",
  "banned_patterns": ["classes", "any", "console.log"],
  "style": "Implicit returns, max 20 lines per function"
}

RECENT WORK

Branch: main

Last 5 commits:
abc1234 refactor: extract auth to /core
def5678 feat: add token validation

Changed files (last commit):
src/auth.ts | 12 +++---
src/utils.ts | 5 +++-

taste: Analyzing last 3 sessions... taste: Collecting session data... taste: Summary created: 18818 bytes taste: Calling opencode for analysis...

LEARNED PATTERNS (last 3 sessions):

NAMING:

functions_describe_action_verbs (confidence: 0.9)
classes_use_PascalCase_Prefixed (confidence: 0.9)
variables_underscore_separated_snake_case (confidence: 0.8)

ARCHITECTURE:

Python_FastAPI_fronts_with_Node_subprocess_backend_via_stdin_stdout_bridge
async_job_queue_with_redis_backend_and_RQ_worker
dual_storage_PDF_disk_and_Redis_cache

IMPORTS:

lazy_import_inside_endpoint_to_avoid_side_effects
from_stdlib_then_third_party_then_local_grouped
explicit_imports_not_star_imports_used

ERROR_HANDLING:

log_then_raise_precise_HTTPException_with_detail
check_rate_limit_before_database_operation
refund_credits_by_saving_values_before_session_closes

STYLE:

short_direct_corrections_fix_agent_behavior_precisely
comment_preservation_expected_across_rewrites

BANNED_PATTERNS:

--single-process_Chromium_flag_on_macOS (reason: causes crashes, documented failure)
hardcoding_connection_URLs_or_env_specific_values (reason: caused 'Queue service unavailable' failure)
jumping_to_implementation_before_design_alignment (reason: wasted work when pricing model wasn't confirmed)
removing_comments_during_code_rewrites (reason: user explicitly called out and expects preservation)
using_browser_only_Node_APIs_in_subprocess (reason: ErrorEvent caused ReferenceError)

Updated: TASTE.md, .agent-taste.json


## Auto-Capture

taste learn automatically captures your current session if no recent session files exist:

```bash
# If docs/session-*.md doesn't exist or is older than 2 hours
taste learn

# It will:
# 1. Capture git history + diffs
# 2. Capture current taste config
# 3. Create docs/session-[YYYY-MM-DD-HHMM].md
# 4. Create prompts/prompt-[YYYY-MM-DD-HHMM].md
# 5. Analyze patterns and update taste config

What it captures:

Git history (last 3 commits + diffs)
Current taste config (.agent-taste.json or TASTE.md)
Last 3-5 session log summaries

What it does NOT capture:

Terminal histories
Agent session logs
Full file contents

Token Optimization

Before taste:

Raw context:
- Session logs: ~40,000 words
- Git diffs: ~10,000 words
- README.md: ~1,000 words
- Session notes: ~500 words
Total: ~51,000 words (~66,000 tokens)

After taste:

Compressed context:
- Taste config: ~120 words
- Git summary: ~200 words
- Session notes: ~200 words
- Agent config: ~500 words
Total: ~1,500 words (~1,950 tokens)

Savings:

Words: 51,000 → 1,500 (97% reduction)
Tokens: 66,000 → 1,950 (97% reduction)

Configuration

Environment Variables

Variable	Default	Description
`TASTE_MODEL`	`opencode/mimo-v2.5-free`	Model to use for `taste learn` analysis

# Set your preferred model
export TASTE_MODEL="anthropic/claude-3-sonnet"

# Or use inline
TASTE_MODEL="openai/gpt-4" taste learn

# Or use command flag (highest priority)
taste learn --model "openai/gpt-4"

Priority: --model flag > TASTE_MODEL env > default

Global Config

Create ~/.config/taste/base.json for global settings:

{
  "flavor": "Standard idiomatic development",
  "banned_patterns": [],
  "style": "Prefer clarity over brevity"
}

Project Config

Create .agent-taste.json in your project root:

{
  "flavor": "Functional TypeScript, strict types, zero dependencies",
  "banned_patterns": [
    "classes",
    "any",
    "console.log"
  ],
  "style": "Implicit returns, max 20 lines per function"
}

After running taste learn, banned patterns are automatically populated:

{
  "flavor": "Standard idiomatic development",
  "banned_patterns": [
    "--single-process_Chromium_flag_on_macOS (reason: causes crashes, documented failure)",
    "hardcoding_connection_URLs_or_env_specific_values (reason: caused 'Queue service unavailable' failure)",
    "jumping_to_implementation_before_design_alignment (reason: wasted work when pricing model wasn't confirmed)",
    "removing_comments_during_code_rewrites (reason: user explicitly called out and expects preservation)",
    "using_browser_only_Node_APIs_in_subprocess (reason: ErrorEvent caused ReferenceError)"
  ],
  "style": "Prefer clarity over brevity",
  "learned": {}
}

FAQ

Does it need a config file? No. An optional .agent-taste.json or TASTE.md can be created, but nothing is required. taste works with zero configuration.

What if I really need that 120-line cache class? You don't. Insist anyway and taste will learn your pattern. Slowly. Correctly. While looking at you.

Does it scale? The context you never waste scales infinitely. Zero tokens wasted, zero generic code, 100% style matching since forever.

Why "taste"? You know exactly why.

Requirements

bash 4.0+
git
opencode or claude (for taste learn)

Future Features

Multi-agent support (claude, codex, commandcode)
Session auto-capture (daemon mode)
Global taste config (~/.config/taste/)
JSON output for agents
Integration with more agent harnesses

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

Fork the repository
Create your feature branch (git checkout -b feature/amazing-feature)
Commit your changes (git commit -m 'Add amazing feature')
Push to the branch (git push origin feature/amazing-feature)
Open a Pull Request

License

MIT. The shortest license that works.