Forem: elias hourany

I Replaced 25 Lines of OpenAI Boilerplate with 6 — Here's the Library

elias hourany — Sun, 15 Feb 2026 14:42:46 +0000

Every time I called an LLM from TypeScript, I wrote the same code. Construct the client. Define a JSON schema by hand. Call chat.completions.create. Parse the response. Cast away the any. Handle the error. Repeat.

After the tenth time copy-pasting that pattern across projects, I built a library to make it disappear. It's called ThinkLang, and this is what it does.

The Problem

Here's what structured output looks like with the raw OpenAI SDK. You want a sentiment analysis result with a label, score, and explanation:

import OpenAI from "openai";

const client = new OpenAI();

const response = await client.chat.completions.create({
  model: "gpt-4o",
  messages: [{ role: "user", content: "Analyze the sentiment of this review: " + review }],
  response_format: {
    type: "json_schema",
    json_schema: {
      name: "Sentiment",
      schema: {
        type: "object",
        properties: {
          label: { type: "string", enum: ["positive", "negative", "neutral"] },
          score: { type: "number" },
          explanation: { type: "string" },
        },
        required: ["label", "score", "explanation"],
      },
    },
  },
});

const result = JSON.parse(response.choices[0].message.content!);
// result is `any` — hope for the best

25 lines. The schema is untyped. The result is any. And you're locked to OpenAI.

The Solution

Here's the same thing with ThinkLang:

import { think, zodSchema } from "thinklang";
import { z } from "zod";

const Sentiment = z.object({
  label: z.enum(["positive", "negative", "neutral"]),
  score: z.number(),
  explanation: z.string(),
});

const result = await think<z.infer<typeof Sentiment>>({
  prompt: "Analyze the sentiment of this review",
  ...zodSchema(Sentiment),
  context: { review },
});

console.log(result.label); // fully typed, autocomplete works

Same result. result is fully typed. Works with Anthropic, OpenAI, Gemini, or Ollama — swap providers by changing one environment variable.

Getting Started

npm install thinklang

Set any provider's API key in your environment (ANTHROPIC_API_KEY, OPENAI_API_KEY, GEMINI_API_KEY, or OLLAMA_BASE_URL) and you're done. No init() call needed — the runtime auto-detects your provider.

import { think } from "thinklang";

const greeting = await think<string>({
  prompt: "Say hello to the world in a creative way",
  jsonSchema: { type: "string" },
});

That's a working program. Five lines.

What Else It Does

Agents with Tools

Define tools with Zod schemas, then let the LLM call them in a loop until it finds the answer:

import { agent, defineTool } from "thinklang";
import { z } from "zod";

const searchDocs = defineTool({
  name: "searchDocs",
  description: "Search documentation",
  input: z.object({ query: z.string() }),
  execute: async ({ query }) => await docsIndex.search(query),
});

const result = await agent({
  prompt: "How do I configure authentication?",
  tools: [searchDocs],
  maxTurns: 5,
});

The agent calls searchDocs as many times as needed (up to maxTurns), then returns a final answer.

Guards

Validate AI output with constraints and auto-retry on failure:

const summary = await think({
  prompt: "Summarize this article",
  jsonSchema: { type: "string" },
  context: { article },
  guards: [{ name: "length", constraint: 50, rangeEnd: 200 }],
  retryCount: 3,
});

If the output is too short or too long, ThinkLang automatically retries up to 3 times.

Batch Processing

Process thousands of items with concurrency control and cost budgets:

import { mapThink, zodSchema } from "thinklang";

const results = await mapThink({
  items: reviews,
  promptTemplate: (r) => `Classify the sentiment: "${r}"`,
  ...zodSchema(Sentiment),
  maxConcurrency: 5,
  costBudget: 2.00, // stop if cost exceeds $2
});

There's also Dataset for lazy, chainable pipelines (think Array.map().filter() but each step goes through an LLM), reduceThink for tree-reduction, and streaming via async generators.

Multi-Provider

No lock-in. Switch providers without changing code:

Provider	Env Var
Anthropic	`ANTHROPIC_API_KEY`
OpenAI	`OPENAI_API_KEY`
Gemini	`GEMINI_API_KEY`
Ollama	`OLLAMA_BASE_URL`

You can also register custom providers with registerProvider() if you're running your own inference.

Built-in Cost Tracking

Every call is tracked automatically:

import { globalCostTracker } from "thinklang";

// ... make some calls ...

const summary = globalCostTracker.getSummary();
console.log(`Total cost: $${summary.totalCostUsd}`);
console.log(`Total tokens: ${summary.totalTokens}`);

Oh, and It's Also a Language

Here's the twist I haven't mentioned yet. ThinkLang is also a programming language. You can write .tl files where AI primitives are first-class keywords:

type Sentiment {
  @description("positive, negative, or neutral")
  label: string
  score: float
  explanation: string
}

let result = think<Sentiment>("Analyze the sentiment of this review")
  with context: review

print result

npm install -g thinklang
thinklang run analyze.tl

The compiler validates types, catches errors before you hit the API, and generates optimized TypeScript. It comes with a VS Code extension (syntax highlighting, snippets, full LSP), a built-in test framework with snapshot replay, and a REPL.

The language is there for teams that want deeper integration. But most people will use the library — and that's by design.

Try It

npm install thinklang

GitHub — Star if you find it useful
Documentation — Full guides, API reference, 32 examples
npm

ThinkLang is MIT licensed and open source. I'd love to hear what you think — drop a comment, open an issue, or just try npm install thinklang and see how it feels.

If you've been writing the same LLM boilerplate I was, I think you'll like it.

Introducing ThinkLang: A Programming Language Where AI Is a First-Class Citizen

elias hourany — Sun, 08 Feb 2026 10:43:55 +0000

What if calling an AI model was as natural as declaring a variable?

Not a library import. Not an API wrapper. Not an SDK call buried in try/catch boilerplate. A keyword -- built into the language itself.

That's the idea behind ThinkLang, an open source programming language I've been building where think, infer, and reason are first-class language primitives. It transpiles to TypeScript and calls an LLM at runtime, but the experience of writing it feels nothing like wiring up API calls.

Today I'm open-sourcing it. Here's why I built it, what it looks like, and where it's going.

The Problem

Every AI application I've built follows the same pattern: write a prompt, call an API, parse JSON, validate the shape, handle errors, retry on failure, track costs, and hope the response matches what I expected. The actual intent -- "analyze the sentiment of this text" -- gets buried under plumbing.

Libraries help, but they don't change the fundamental experience. You're still writing code about calling an AI, rather than code that thinks.

I wanted a language where the AI call disappears into the syntax. Where the compiler enforces type safety on AI outputs. Where uncertainty is a type, not an afterthought.

The Simplest Example

Here's a complete ThinkLang program:

let greeting = think<string>("Say hello to the world in a creative way")
print greeting

That's it. think is a keyword. The generic parameter <string> tells the compiler (and the AI) what type to return. The prompt is the argument. No imports, no configuration, no SDK initialization.

But ThinkLang is not a toy. It's designed for building real AI applications with the same rigor you'd expect from any typed language.

Type-Safe AI Outputs

The real power shows up when you define structured types:

type Sentiment {
  @description("positive, negative, or neutral")
  label: string
  @description("Intensity from 1-10")
  intensity: int
}

let review = "This product is absolutely amazing! Best purchase I've ever made."

let sentiment = think<Sentiment>("Analyze the sentiment of this review")
  with context: review

print sentiment

The type declaration compiles to a JSON schema that constrains the AI's output. The @description annotations guide the model without polluting your prompt. And the with context: clause passes data to the AI while keeping the prompt clean.

If the model returns something that doesn't match the schema, ThinkLang throws a SchemaViolation -- not a mysterious runtime error three function calls later.

Making Uncertainty Explicit

AI outputs are inherently uncertain. Most languages pretend otherwise. ThinkLang has a Confident<T> wrapper that makes uncertainty a first-class concept:

let sentiment = think<Confident<Sentiment>>("Analyze the sentiment of this review")
  with context: review

A Confident<T> value carries the data, a confidence score, and the model's reasoning. You can't just use it as if it were a plain value -- you have to explicitly handle the uncertainty:

// Extract the value, or throw if confidence < 0.8
let result = sentiment.unwrap(0.8)

// Use a fallback if confidence is low
let safe = sentiment.or(defaultSentiment)

This forces you to make a conscious decision about how much you trust the AI's output. It's a small syntactic cost that prevents an entire category of bugs.

Three Ways to Think

ThinkLang provides three AI primitives, each for a different use case:

think -- structured generation. Give it a prompt and a type, get back validated data:

let analysis = think<Sentiment>("Analyze the sentiment of this review")
  with context: review

infer -- lightweight classification and transformation. No type definition needed for quick operations:

let priority = infer<string>("urgent: server is down!", "Classify as low, medium, high, or critical")
let language = infer<string>("Bonjour le monde", "Detect the language")

reason -- multi-step reasoning with explicit goals. For complex tasks that benefit from chain-of-thought:

type InvestmentAnalysis {
  recommendation: string
  riskLevel: string
  expectedReturn: string
  reasoning: string
}

let analysis = reason<InvestmentAnalysis> {
  goal: "Analyze this investment portfolio and provide recommendations"
  steps:
    1. "Evaluate the current asset allocation"
    2. "Assess market conditions impact on each asset class"
    3. "Identify risks and opportunities"
    4. "Formulate a recommendation"
  with context: {
    portfolio,
    marketConditions,
  }
}

The reason block makes the chain-of-thought explicit in the code. Each step is visible, reviewable, and debuggable -- not hidden inside a system prompt.

Guards: Declarative Output Validation

Sometimes schema validation isn't enough. You need to constrain the content, not just the shape. ThinkLang has guards:

let summary = think<string>("Summarize this article")
  with context: article
  guard {
    length: 50..200
    contains_none: ["TODO", "placeholder"]
  }
  on_fail: retry(3) then fallback("Summary unavailable")

Guards are declarative constraints on the AI's output. If the output fails validation, ThinkLang automatically retries with exponential backoff. If all retries fail, the fallback kicks in. No manual retry loops. No scattered error handling.

Pattern Matching on AI Data

ThinkLang has native pattern matching that works naturally with AI-generated structured data:

let sentiment = think<Confident<Sentiment>>("Analyze the sentiment")
  with context: review

let response = match sentiment {
  { confidence: >= 0.9 } => "High confidence result"
  { confidence: >= 0.5 } => "Moderate confidence result"
  _ => "Low confidence -- manual review needed"
}

This makes branching on AI outputs clean and readable, replacing chains of if/else statements that check confidence thresholds and field values.

Error Handling That Knows About AI

ThinkLang has a typed error hierarchy designed for AI failure modes:

try {
  let result = think<Summary>("Summarize this text in detail")
    with context: text
  print result
} catch SchemaViolation (e) {
  print "Schema error occurred"
} catch ConfidenceTooLow (e) {
  print "Confidence too low for reliable result"
}

SchemaViolation, ConfidenceTooLow, GuardFailed -- these are specific, catchable error types, not generic exceptions. You can handle each failure mode differently because the language understands what can go wrong with AI calls.

Context Privacy

When you're passing data to an AI, sometimes you need to include context for your code but exclude sensitive fields from the LLM call:

let recommendation = think<Recommendation>("Suggest products based on user interests")
  with context: {
    profile,
    sensitiveData,
  }
  without context: sensitiveData

The without context: clause strips fields before they reach the model. Privacy controls are part of the language, not an afterthought in a middleware layer.

Built-In Cost Tracking

Every AI call in ThinkLang is automatically tracked. No instrumentation required:

$ thinklang run analyze.tl --show-cost

# Output includes:
# Total cost: $0.0234
# Breakdown: 3 think calls ($0.0180), 2 infer calls ($0.0054)
# Model: claude-opus-4-6 | Tokens: 1,240 in / 890 out

You can also run thinklang cost-report for aggregate summaries across runs. Cost awareness is built into the development workflow, not discovered in a billing dashboard weeks later.

Testing AI Code

Testing non-deterministic AI outputs is hard. ThinkLang's built-in testing framework addresses this with two key features:

Semantic assertions -- test meaning, not exact strings:

test "sentiment analysis" {
  let result = think<Sentiment>("Analyze sentiment")
    with context: "I love this product!"
  assert result.label == "positive"
  assert.semantic(result, "correctly identifies positive sentiment")
}

Deterministic replay -- record AI responses once, replay them forever:

$ thinklang test --update-snapshots   # Record live responses
$ thinklang test --replay             # Replay from snapshots (no API calls, no cost)

Snapshot replay means your CI pipeline can run AI tests without an API key, without network access, and without cost. Development iteration becomes fast and free.

The Tooling

ThinkLang ships with a complete development environment:

CLI with run, compile, repl, test, and cost-report commands
VS Code extension with syntax highlighting, 11 code snippets, and a full LSP server providing diagnostics, hover information, completions, go-to-definition, and signature help
Response caching that automatically deduplicates identical AI calls at zero cost
Module system with imports for reusing types and functions across files

How It Works Under the Hood

ThinkLang follows a traditional compiler pipeline: parse -> resolve imports -> type check -> code generate.

A PEG grammar parses .tl files into an AST
The module resolver handles imports (with circular dependency detection)
The type checker validates scope and types
The code generator emits TypeScript that imports from the ThinkLang runtime

The runtime uses the Anthropic SDK with JSON schema mode for structured outputs, automatic retries, confidence extraction, and cost tracking. Types are compiled to JSON schemas that constrain the model's response format.

Getting Started

npm install thinklang

# Set your API key
export ANTHROPIC_API_KEY=sk-ant-...

# Run your first program
echo 'let greeting = think<string>("Say hello")' > hello.tl
npx thinklang run hello.tl

17 example programs in the examples/ directory cover every feature, from basic think calls to multi-step reasoning with guards and pattern matching.

Why Open Source

ThinkLang is MIT licensed and open source because the idea of AI-native programming languages is bigger than one project. I want to see what happens when the community pushes on these concepts -- when people find use cases I haven't imagined, syntax improvements I haven't considered, and patterns that only emerge at scale.

The language is at version 0.1.1. The grammar, runtime, and tooling are functional and tested (13 test suites), but there's plenty of room to grow: more model providers, richer type system features, optimization passes, and whatever else the community decides matters.

Links

GitHub: github.com/eliashourany/ThinkLang
Documentation: thinklang.dev
VS Code Extension: Search "ThinkLang" in the marketplace

If you've ever felt that calling an AI should be simpler -- that it should feel like part of the language, not something bolted on -- give ThinkLang a try. Star the repo, file an issue, or open a PR. I'd love to hear what you think.

ThinkLang is built by Elias Hourany. If you found this interesting, follow me for updates on the project.

I Built a Programming Language Where think Is a Keyword

elias hourany — Sat, 07 Feb 2026 18:25:41 +0000

We write if, for, and return every day without a second thought. These are the primitives of computation — the building blocks we use to tell machines what to do.

But we're in a new era now. AI isn't a service you call occasionally — it's becoming a fundamental computing primitive. So why are we still using it like this?

const response = await anthropic.messages.create({
model: "claude-opus-4-6",
max_tokens: 1024,
messages: [{ role: "user", content: "Analyze the sentiment of: " + text }],
});
const result = JSON.parse(response.content[0].text);
// hope it's the right shape...

API boilerplate. Manual prompt construction. Untyped JSON parsing. Praying the response matches what you expected.

What if instead, you could just write:

let sentiment = think("Analyze the sentiment of this review")

That's why I built ThinkLang — an open-source, AI-native programming language where think is a keyword.

What Is ThinkLang?

ThinkLang is a transpiler. You write .tl files, and the compiler turns them into TypeScript that calls an LLM runtime. The language has its own parser (PEG
grammar), type checker, code generator, LSP server, VS Code extension, testing framework, and CLI.

The compilation pipeline: parse → resolve imports → type check → code generate → execute.

The core idea is simple: AI should be a language-level primitive, not a library call.

The Basics: think, infer, reason

ThinkLang has three AI primitives built into the language:

think(prompt)

The primary primitive. Give it a type and a prompt, and it returns structured, type-safe output.

type MovieReview {
title: string
rating: int
pros: string[]
cons: string[]
verdict: string
}

let review = think("Review the movie Inception")

print(review.title) // type-safe access
print(review.rating) // guaranteed to be an int

The compiler turns your type declaration into a JSON schema that constrains the LLM's output. The AI cannot return anything that violates your type. No
parsing. No validation. No hoping.

infer(value)

Lightweight inference on existing values — when you already have data and want the AI to derive something from it.

type Category {
label: string
confidence: float
}

let data = "The patient presents with a persistent cough and fever"
let category = infer(data)

reason {}

Multi-step reasoning with explicit goals and steps:

type Analysis {
findings: string[]
recommendation: string
risk_level: string
}

let analysis = reason {
goal: "Evaluate this investment opportunity"
steps:
1. "Analyze the financial fundamentals"
2. "Assess market conditions and competition"
3. "Evaluate risk factors"
4. "Form a final recommendation"
with context: { portfolio, market_data }
}

This compiles into a structured chain-of-thought prompt. The AI follows your steps explicitly rather than reasoning however it wants.

Confidence as a Language Concept

Here's something most AI wrappers get wrong: they treat every AI response as equally certain. But AI outputs have varying levels of confidence, and your code
should reflect that.

ThinkLang has Confident:

type Diagnosis {
condition: string
severity: string
}

let result = think>("Diagnose based on these symptoms")

print(result.value) // the actual diagnosis
print(result.confidence) // 0.0 to 1.0
print(result.reasoning) // why the AI is this confident

And the uncertain modifier forces you to handle uncertainty explicitly:

uncertain let diagnosis = think>("Diagnose this")

// This won't compile:
// print(diagnosis.value)

// You must explicitly unwrap:
let safe = diagnosis.expect(0.8) // throws if confidence < 0.8
let fallback = diagnosis.or(default_val) // use fallback if low confidence
let raw = diagnosis.unwrap() // explicit "I accept the risk"

The compiler enforces this. You can't silently ignore uncertainty — you have to make a conscious decision about how to handle it.

Output Guards

What if the AI returns something that's technically the right type but semantically wrong? A summary that's too long. A response that contains placeholder
text. A rating that's out of range.

Guards are declarative validation rules with automatic retry:

let summary = think("Summarize this article")
guard {
length: 50..200
contains_none: ["TODO", "placeholder", "as an AI"]
}
on_fail: retry(3) then fallback("Could not generate summary")

If the output fails validation, ThinkLang automatically retries up to 3 times. If all retries fail, it falls back to your default. No manual retry loops. No
callback hell.

You can also guard numeric fields:

let review = think("Review this product")
guard {
rating: 1..5
length: 100..500
}
on_fail: retry(2)

Pattern Matching on AI Outputs

ThinkLang has structural pattern matching that works beautifully with AI-generated data:

type Sentiment {
label: string
intensity: int
}

let sentiment = think("Analyze: 'This is the best day ever!'")

match sentiment {
{ label: "positive", intensity: >= 8 } => print("Extremely positive!")
{ label: "positive" } => print("Positive")
{ label: "negative", intensity: >= 8 } => print("Extremely negative")
{ label: "negative" } => print("Negative")
_ => print("Neutral")
}

Pattern matching + typed AI outputs = clean, readable branching on AI results.

Context Management

Control exactly what data the AI sees:

let user_profile = { name: "Alice", preferences: ["sci-fi", "thriller"] }
let secret_key = "sk-abc123"

let recommendation = think("Recommend a movie for this user")
with context: user_profile
without context: secret_key

with context scopes data into the prompt. without context explicitly excludes sensitive data. No accidentally leaking API keys into prompts.

Pipeline Operator

Chain AI operations with |>:

let result = "raw text input"
|> think("Summarize this")
|> think("Translate to French")
|> think("Rate the translation quality")

Readable, composable, functional-style AI pipelines.

Built-in Testing Framework

This is one of my favorite features. ThinkLang has a built-in test framework that understands AI:

test "sentiment analysis" {
let result = think("Analyze: 'I love this product'")

assert result.label == "positive"
assert result.intensity > 5

}

test "summary quality" {
let summary = think("Summarize the theory of relativity")

assert.semantic(summary, "explains relationship between space and time")
assert.semantic(summary, "mentions Einstein")

}

assert.semantic() is an AI-powered assertion. It uses the LLM to evaluate whether the output meets qualitative criteria. No brittle string matching.

Snapshot Replay

AI tests are non-deterministic and cost money. ThinkLang solves both problems:

# Record AI responses to snapshot files
thinklang test --update-snapshots

# Replay from snapshots — zero API calls, deterministic results
thinklang test --replay

Record once, replay forever. Your CI pipeline runs deterministic AI tests without an API key.

Cost Tracking

Every AI call is automatically metered:

thinklang run my-program.tl --show-cost

Cost Summary:
Total calls: 5
Input tokens: 2,847
Output tokens: 1,203
Estimated cost: $0.0234

By operation:
  think: 3 calls, $0.0156
  reason: 1 call, $0.0062
  assert.semantic: 1 call, $0.0016

You can also run thinklang cost-report to see aggregated costs across runs. No surprises on your API bill.

Full Developer Ecosystem

ThinkLang isn't just a language — it's a complete toolchain:

CLI with run, compile, repl, test, and cost-report commands
VS Code extension with syntax highlighting and 11 code snippets
Language Server (LSP) providing real-time diagnostics, hover tooltips, code completion, go-to-definition, document symbols, and signature help
Module system with import/export across .tl files
Response caching — identical prompts skip the API call automatically
17 example programs covering every feature

How I Built It

I built ThinkLang as a solo developer, and I have to be honest — Claude Code was an incredible partner throughout the process. It helped me move fast, iterate
on the parser grammar, debug the type checker, and ship a project of this scope. Building an entire language ecosystem (parser, checker, compiler, runtime,
LSP, testing framework, VS Code extension, docs) solo would have taken significantly longer without it. AI-assisted development is real, and this project is
proof of it.

The technical stack:

PEG grammar (Peggy) for parsing
TypeScript for the compiler, runtime, and tooling
Zod for runtime validation
Anthropic SDK for the AI runtime
vscode-languageserver for the LSP
VitePress for the documentation site

What's Next

ThinkLang is at v0.1.1 and I have big plans:

Model Agnostic Support — Right now ThinkLang uses Anthropic's Claude. The next milestone is supporting any provider: OpenAI, Gemini, Mistral, local models via
Ollama, or any OpenAI-compatible endpoint. Same language, any brain.

Agentic Native Coding — First-class language primitives for building AI agents. Think tool use, planning loops, and multi-agent coordination as language
keywords, not library patterns.

Try It

npm install -g thinklang

Create hello.tl:

type Greeting {
message: string
emoji: string
}

let greeting = think("Say hello to a developer trying ThinkLang for the first time")
print(greeting.message)
print(greeting.emoji)

Run it:

thinklang run hello.tl

Links:

GitHub: https://github.com/eliashourany/ThinkLang
Docs: https://thinklang.dev
npm: https://www.npmjs.com/package/thinklang

The project is MIT licensed. I'd love stars, feedback, issues, or contributions. And if you're thinking about what AI-native development looks like — let's
talk.