Turn plain-language requests - a whole file, or a quick @human note in your code - into real code in seconds.
Write less. Stay in control.
npx human-to-code .
Create a reusable TypeScript function that:
- accepts an array of numbers
- returns a new sorted array
- never mutates the input
sort.ts
export function sortNumbers(
items: number[],
): number[] {
return [...items].sort((a, b) => a - b);
}generated TypeScript from human intent
sort.ts (before)
export type SortOrder = "asc" | "desc";
/* @human
Implement sortNumbers with:
- immutable output
- ascending and descending order
*/export type SortOrder = "asc" | "desc";
export function sortNumbers(items: number[], order: SortOrder) {
const sorted = [...items].sort((a, b) => a - b);
return order === "desc" ? sorted.reverse() : sorted;
}marker replaced in sort.ts
sort.js (before)
/* @human
Create sortBy that:
- accepts an array and selector function
- returns a new array
- keeps the original array unchanged
*/export function sortBy(items, select) {
return [...items].sort((a, b) => {
const left = select(a);
const right = select(b);
return left < right ? -1 : left > right ? 1 : 0;
});
}marker replaced in sort.js
sort.py (before)
from collections.abc import Iterable
""" @human
Implement sort_numbers:
- accept an Iterable of numbers
- return a new ascending list
- never mutate the input
"""from collections.abc import Iterable
def sort_numbers(
items: Iterable[float],
) -> list[float]:
return sorted(items)marker replaced in sort.py
sort.rs (before)
#[derive(Clone)]
pub struct Score {
pub value: i32,
}
/* @human
Implement sort_scores:
- take a borrowed slice
- return a new Vec
- sort by value ascending
*/#[derive(Clone)]
pub struct Score {
pub value: i32,
}
pub fn sort_scores(scores: &[Score]) -> Vec<Score> {
let mut sorted = scores.to_vec();
sorted.sort_by_key(|score| score.value);
sorted
}marker replaced in sort.rs
12 languages work today, with extra know-how for React, NestJS, FastAPI & Rust projects - more are on the roadmap
Private by default - nothing leaves your computer unless you pick a cloud AI and say yes.
A provider is simply the AI that writes the code for you. Two options: Ollama runs an AI model on your own computer - free, and nothing leaves your machine. OpenAI runs in the cloud - used only after you turn it on and agree. Works anywhere Node.js 24+ runs.
Ollama is a free app that runs AI models on your own computer. Install it, then download ("pull") the model once - the default is qwen2.5-coder:7b. human-to-code talks to it right on your machine, so your code stays with you.
ollama pull qwen2.5-coder:7bYour key stays private. The settings file only remembers the name of the environment variable (OPENAI_API_KEY) - never the key itself.
export OPENAI_API_KEY="your_api_key"
--init creates a ready-to-edit settings file called human-to-code.config.json. It never overwrites one you already have.
npx human-to-code --init .The new settings file already points to local Ollama - no edits needed.
Switch the provider to OpenAI, set a spending limit, and set remoteProviderConsent to true to allow cloud use.
Write what you want in a .human file (or an @human comment), then run the command. It shows exactly what it will do and asks before writing anything.
npx human-to-code .Two simple ways to go from plain words to code - pick whichever fits you.
Write your request in a *.human file. The finished code is saved right next to it, with the same name (the file type matches the language you chose).
# greet.humanWrite a function that takes a name and returnsa friendly greeting, with a docstring.$ npx human-to-code .yes wrote greet.pyAdd a short @human comment inside a file you already have, using that language's normal comment style - for example /* @human ... */ in TypeScript or JavaScript, or """ @human ... """ in Python. human-to-code replaces the comment with real code, right where it sat.
// utils.ts// @human debounce helper with cancel()$ npx human-to-code .yes wrote utils.tsBefore writing, it shows a short summary - which files, which AI, which model - and asks first. With --dry-run it shows the plan and writes nothing.
The essentials - the full README covers everything.
# default: find .human files and @human
# comments, show a summary, write code
npx human-to-code .
# create a settings file (never overwrites)
npx human-to-code --init .
Needs Node.js 24+. Out of the box it uses Ollama on your own computer (model qwen2.5-coder:7b), so nothing leaves your machine until you switch to a cloud AI and say yes.
Ollama
OpenAI
A provider is the AI that writes the code. Two are supported today: Ollama (free, runs on your computer) and OpenAI (runs in the cloud). Your API key is never saved - the settings file only stores the name of the environment variable, like OPENAI_API_KEY. Cloud use stays off until you turn it on and set a spending limit.
human-to-code . - find your .human files and @human comments, show a summary, and write the code--init - create a settings file (won't overwrite an existing one)--dry-run - see the plan without writing anything--yes - skip the confirmation questionBefore anything is sent to the AI, it scans for secrets like passwords and keys. It checks the generated code before saving, makes sure separate files still fit together, and always asks before writing. More in SECURITY.md.