Kukicha
AI-assisted coding.
You describe what you want. AI writes the code. Kukicha lets you read it.
Kukicha is a programming language designed to be read by humans and written by AI agents. It compiles to Go, so your programs run fast and deploy as a single binary with no dependencies.
The Workflow
You describe what you want
↓
AI agent writes Kukicha
↓
You read and approve it ← Kukicha makes this step possible
↓
kukicha build → single binary
↓
Ship it
You don't need to know how to write Kukicha as long as you can read it and spot when something looks wrong.
See the Agent Workflow Tutorial to get started immediately.
Here's What AI-Generated Kukicha Looks Like
See if you can follow it:
import "stdlib/fetch"
import "stdlib/slice"
type Repo
name string as "name"
stars int as "stargazers_count"
func main()
repos := fetch.Get("https://api.github.com/users/golang/repos")
|> fetch.CheckStatus()
|> fetch.Json(list of Repo) onerr panic "fetch failed: {error}"
popular := repos |> slice.Filter(repo => repo.stars > 1000)
for repo in popular
print("{repo.name}: {repo.stars} stars")
What just happened: This program fetches a list of repositories from GitHub, keeps only the ones with more than 1,000 stars, and prints each name with its star count. The |> (pipe) passes the result of one step into the next. onerr panic means "if something goes wrong, stop and show this message."
What to Read in Agent-Generated Code
When AI writes Kukicha for you, here's the decoder ring:
| You'll see |
It means |
onerr panic "message" |
If this fails, crash with message |
onerr return |
If this fails, pass the error up |
onerr 0 or onerr "unknown" |
If this fails, use this default value |
|> |
Then pass result to the next step |
expr |> switch |
Pipe a value into a switch (choose based on it) |
expr |> switch as v |
Pipe a value into a type switch (branch on its type) |
list of string |
A collection of text values |
map of string to int |
A lookup table: text key → number |
reference User |
A reference to a User (like a bookmark) |
(x) => x + 1 |
A shorthand function: given x, return x + 1 |
for item in items |
Do this for each item |
:= |
Create a new variable |
defer f() |
Clean up when this function exits |
petiole main |
This file belongs to the main package |
Key question when reviewing: Does each onerr say what to do when something fails? If it panics, is that appropriate? If it returns an error, will the caller handle it?
Quickstart
Prerequisites
Go 1.26+ is required. If you don't have Go installed, download it here.
Install Kukicha
Option A — Binary download (no Go toolchain needed after install):
Download a pre-built binary from GitHub Releases.
Option B — Install with Go:
go install github.com/duber000/kukicha/cmd/kukicha@v0.0.16
kukicha version
Your First Project
mkdir myapp && cd myapp
kukicha init # sets up your project and stdlib
Create a file called hello.kuki:
# hello.kuki
func main()
name := "World"
print("Hello, {name}!")
Then run it:
kukicha run hello.kuki
Which Command Do I Use?
| Command |
What it does |
When to use it |
kukicha check file.kuki |
Validates syntax without running anything |
Before committing — catches errors early |
kukicha run file.kuki |
Compiles and runs immediately |
While developing and testing |
kukicha build file.kuki |
Compiles to a standalone binary |
When you're ready to ship |
What Can You Build?
import "stdlib/mcp"
import "stdlib/fetch"
func getPrice(symbol string) string
price := fetch.Get("https://api.example.com/price/{symbol}")
|> fetch.CheckStatus()
|> fetch.Text() onerr return "unavailable"
return "{symbol}: {price}"
func main()
server := mcp.NewServer()
server |> mcp.Tool("get_price", "Get stock price by ticker symbol", getPrice)
server |> mcp.Serve()
Compile to a single binary and register it with Claude Desktop or any MCP-compatible agent.
A Simple Automation Script
import "stdlib/files"
import "stdlib/string"
func main()
content := "notes.txt" |> files.Read() onerr panic "can't read file: {error}"
lines := content |> string.Split("\n")
for line in lines
if line |> string.Contains("TODO")
print(line)
Read a file, find every line containing "TODO", and print them out.
import "stdlib/cli"
import "stdlib/semver"
import "stdlib/shell"
import "stdlib/sort"
import "stdlib/table"
func main()
repos := listMyRepos() onerr panic "{error}"
entries := repos
|> slice.Map(r => buildEntry(r, bump))
|> sort.ByKey(e => e.name)
t := table.New(list of string{"repo", "current", "next"})
for entry in entries
t = t |> table.AddRow(list of string{entry.name, entry.current, entry.next})
t |> table.Print()
Parse semver tags, sort repos, and display a formatted table — all with stdlib pipes. See the full gh-semver-release example.
More examples: AI commit messages, Concurrent URL health checker, REST API link shortener, CLI repo explorer, Semver release tool
Beyond Readability
Kukicha compiles to Go — single binaries, goroutines, strong typing, memory safety, fast cold starts. No runtime dependencies.
But readability alone isn't enough. AI writes nearly half of all committed code, yet 45% of it contains security flaws and AI-generated code introduces 1.7x more issues. In 2026, security debt hit 82% of organizations and AI-generated code introduces 15–18% more security vulnerabilities at enterprise scale.
The Kukicha compiler catches common AI-generated vulnerabilities at build time — SQL injection, XSS, SSRF, path traversal, command injection, and open redirects — and tells both you and the AI agent what safe alternative to use instead.
AI is the writer. You are the editor.
For Developers
If you already know Go or Python, here's how Kukicha compares:
|
Go |
Python |
Kukicha |
| Reads like English |
Partially |
Yes |
Yes |
| Classes / OOP required |
No |
Common |
No |
Special symbols (&&, __, **) |
&& |
__, ** |
No |
| Compiles to single binary |
Yes |
No |
Yes (via Go) |
| Built for AI generation + human review |
No |
No |
Yes |
| Transfers to Go/Python |
— |
— |
1:1 |
Every Kukicha concept maps 1:1 to Go and Python — see the Quick Reference for a full translation table.
Standard Library
41+ packages, pipe-friendly, error-handled with onerr.
| Category |
Packages |
| Data |
fetch, files, json, parse, encoding, cast |
| Logic |
slice, maps, string, math, sort (custom comparators, ByKey), iterator (lazy iter.Seq pipelines), random |
| Security |
crypto (SHA-256, HMAC, secure random), netguard, sandbox |
| Infrastructure |
pg, kube, container, shell, net |
| AI & Agents |
llm, mcp, a2a, accel / infer (ONNX inference) |
| Web |
http, fetch, validate, template |
| Config & Ops |
env, must, cli, semver, obs, retry, ctx, datetime, concurrent |
| Output |
table (terminal tables: plain, box, markdown), input (interactive prompts) |
| Errors & Testing |
errors, test |
See the full Stdlib Reference.
Editor Support
VS Code: Search kukicha-lang in extensions, or download the .vsix from GitHub Releases. See editors/vscode/README.md.
Zed: Open Zed → zed: install dev extension → point to editors/zed/ in this repo.
Other editors: make install-lsp and configure your editor to run kukicha-lsp for .kuki files.
All editors get syntax highlighting, hover, go-to-definition, completions, and diagnostics via the LSP.
Documentation
New to Kukicha?
Build something real:
Go deeper:
Contributing
See Contributing Guide for development setup, tests, and architecture.
Status
Version: 0.0.16 — Ready for testing
Go: 1.26.1+ required
License: See LICENSE