Tycode

Tycode is an AI-powered coding assistant that operates as both a command-line tool and a Visual Studio Code extension. Tycode follows a bring-your-own-key model where you maintain direct control over your AI provider and costs. You pay your AI provider directly (AWS Bedrock or OpenRouter) rather than through a subscription service.

Installation

Start by cloning the repository and building the distribution package:

git clone https://github.com/tigy32/Tycode
cd Tycode
./dev.sh package

This build process produces both the CLI binary and the VSCode extension package.

Command Line Interface

The CLI can be run directly from the repository using Cargo:

cargo run --bin tycode

Visual Studio Code Extension

The packaging script generates a VSIX file in the tycode-vscode directory. Install it through VSCode by opening the command palette (Cmd+Shift+P or Ctrl+Shift+P), selecting "Extensions: Install from VSIX", and choosing the generated file.

Configuration

Tycode stores its configuration in ~/.tycode/settings.toml. While you can edit this file directly, the recommended approach is to use the built-in commands to manage your settings.

Provider Setup

You must configure an AI provider before using Tycode. The system supports four options:

AWS Bedrock requires an AWS account with access to Bedrock's LLM services. You'll need an AWS CLI profile configured with appropriate credentials. To configure Bedrock as your provider:

/provider add <name> bedrock <profile-name>

For example, if your AWS profile is named "default":

/provider add default-bedrock bedrock default

OpenRouter provides a simpler alternative and is recommended unless you must run in AWS. OpenRouter aggregates multiple LLM providers under a single API. Configuration follows a similar pattern:

/provider add <name> openrouter <api-key>

Claude Code allows you to use your Claude subscription with Tycode by leveraging the claude CLI command. This provider is ideal if you already have a Claude.ai subscription and want to use those credits directly:

/provider add <name> claude_code

You can optionally specify a custom command path or additional arguments if your claude CLI is installed in a non-standard location.

Codex CLI allows you to use OpenAI Codex through the local codex CLI executable:

/provider add <name> codex

You can optionally pass a custom command path and extra CLI arguments, similar to claude_code.

Cost Controls

You can control the cost and quality of responses by specifying a cost tier:

/cost set <tier>

Available tiers include unlimited for maximum quality (using top-tier models like Claude), low for budget-conscious usage (currently routing to models like Grok-2-fast), and intermediate options. The low tier provides surprisingly capable performance for everyday development tasks while minimizing costs.

Example Configuration

A typical configuration file looks like this:

active_provider = "default"
model_quality = "unlimited"
review_level = "None"

[providers.default]
type = "bedrock"
profile = "default"
region = "us-west-2"

This configuration uses AWS Bedrock through the "default" profile and sets quality to unlimited.

Using Tycode

Tycode operates within strict directory boundaries. The model cannot read or write files outside the current workspace (in VSCode) or working directory (in the CLI). This sandboxing ensures that the AI remains focused on your current project and cannot accidentally modify unrelated files.

The model respects your .gitignore file and will treat ignored files as if they do not exist. This prevents the AI from reading build artifacts, dependencies, or other files you've chosen to exclude from version control.

Working with git is strongly recommended. Models can occasionally damage code while attempting to implement features, and having version control makes recovery trivial. A productive workflow starts from a clean git state, lets the AI make progress on a feature, and commits only once the implementation is complete and working. If something goes wrong during development, you can simply revert the changes and try a different approach.

Skills

Tycode supports Claude Code Agent Skills - modular capabilities that extend the agent with specialized workflows. Skills are automatically discovered and can be invoked when the AI detects a matching request.

Skill Discovery

Skills are discovered from the following locations (in priority order):

1. ~/.claude/skills/ - User-level Claude Code compatibility
2. ~/.tycode/skills/ - User-level Tycode skills
3. .claude/skills/ in workspace - Project-level Claude Code compatibility
4. .tycode/skills/ in workspace - Project-level (highest priority)

Creating a Skill

Each skill is a directory containing a SKILL.md file with YAML frontmatter:

---
name: my-skill
description: When to use this skill
---

# My Skill Instructions

Step-by-step instructions for the AI to follow...

Using Skills

List available skills:

/skills

Manually invoke a skill:

/skill <name>

View skill details:

/skills info <name>

Skills are also automatically invoked when the AI detects a user request matching a skill's description.

MCP Server Configuration

Tycode supports MCP servers over both stdio and HTTP transports. You can add or remove MCP servers using slash commands.

To add a stdio MCP server (local command):

/mcp add <name> <command> [--args "args..."] [--env "KEY=VALUE"]

To add an HTTP MCP server (remote URL):

/mcp add <name> --url <url> [--header "Name: Value"]

To remove an MCP server:

/mcp remove <name>

Installed MCP servers are stored in your configuration file. Examples:

# Stdio server (local command)
[mcp_servers.fetch]
command = "uvx"
args = ["mcp-server-fetch"]

# HTTP server (remote URL)
[mcp_servers.remote]
url = "http://localhost:8000/mcp"

[mcp_servers.remote.headers]
Authorization = "Bearer your-token"