DEV Community: youxufkhan

Free AI Coding CLI Tools in 2026: A Practical Guide

youxufkhan — Sat, 18 Apr 2026 15:56:52 +0000

AI coding assistants have become essential in modern development workflows. But with the big players pivoting to paid models, finding a free or affordable option is getting harder. Here's what actually works and how to set it up in minutes.

The Problem with Major AI Coding Tools

Claude Code remains the gold standard for CLI-based AI coding. It's powerful, well-integrated, and handles complex codebases beautifully. But the pay-as-you-go pricing adds up fast. If you're using it heavily throughout the day, the costs can surprise you.

Google Gemini initially offered a generous free tier with their top models (Gemini 2.5 and 2.5 Pro). But recent quota changes have made free access significantly more restrictive. The writing is on the wall free tiers rarely survive.

Qwen (Alibaba's Qwen 2.5 Coder) offered a compelling free alternative through their CLI, but they ended their free tier just last week. If you were counting on it, too bad.

OpenAI's Codex is currently free but as the saying goes, "free until it isn't." The tier exists, but how long it lasts is anyone's guess.

Free and Open Source Alternatives That Actually Work

Opencode CLI

My personal favorite. Opencode offers free models through Opencode Zen with surprisingly generous limits. The tool itself is open-source and you can use it for free, or upgrade to paid plans ($5-20/month) for higher limits and more models.

What sets Opencode apart:

Built-in skills system for specialized tasks
Active plugin ecosystem
Great documentation
Runs locally with your choice of models

Kilo CLI

Another solid open-source option. Kilo routes through their gateway and includes built-in agents: Plan, Build, Debug, and Orchestrator. They offer decent free models without requiring a paid subscription.

Supercharge Opencode with Plugins

One of Opencode's strengths is its plugin ecosystem. Here are three plugins worth adding:

oh-my-openagent (52.5k ⭐)

Previously called "oh-my-opencode", this is a beast. It gives you a full AI dev team:

Sisyphus - Main orchestrator that plans, delegates to specialists, and drives tasks to completion
Hephaestus - Autonomous deep worker for end-to-end execution
Prometheus - Strategic planner that interviews you before touching code

Features include:

ultrawork command - one word, all agents activate and don't stop until done
Hash-anchored edits - prevents stale-line errors
Built-in MCPs (web search, official docs, GitHub search)
Ralph Loop - self-referential loop that keeps working until 100% done

Superpowers (159k ⭐)

A complete software development methodology. The workflow:

brainstorming - Refines your idea before writing code
using-git-worktrees - Creates isolated workspace on new branch
writing-plans - Breaks work into 2-5 minute tasks
subagent-driven-development - Dispatches agents per task with two-stage review
test-driven-development - Enforces RED-GREEN-REFACTOR
requesting-code-review - Reviews before continuing
finishing-a-development-branch - Verifies tests, presents merge options

Skills include systematic-debugging, verification-before-completion, and writing-skills.

Agency (82k ⭐)

50+ specialized agents across different divisions:

Engineering: Frontend Developer, Backend Architect, AI Engineer, DevOps, Security Engineer, SRE, Database Optimizer, Technical Writer

Design: UI Designer, UX Researcher, Brand Guardian, Whimsy Injector, Visual Storyteller

Marketing: Growth Hacker, Content Creator, SEO Specialist, Twitter Engager, TikTok Strategist

Sales: Outbound Strategist, Deal Strategist, Sales Engineer, Pipeline Analyst

Each agent has personality, processes, and measurable deliverables.

My Solution: One-Command Setup

I got tired of manually configuring Opencode with the plugins and free models I wanted. So I built my-opencode-config a tool that sets up everything in one command:

Installs Opencode with OhMyOpenagent
Pre-configures Superpowers and Agency agents
Sets up Gemini free models via OAuth
Configures Opencode Zen free models

Installation

npx my-opencode-config

Or check out the GitHub repo for more options.

That's it. One command and you have a fully configured AI coding CLI with free models and premium plugins.

What I Use Daily

For my daily coding:

Opencode as my primary CLI (configured via my-opencode-config)
Kilo as backup when I need different model quirks
Claude Code for specific tasks where it shines

The Takeaway

The landscape shifts fast. Free tiers come and go. But the tools above work today and my setup script gives you a running start without the configuration headaches.

What are you using for AI-assisted coding? Drop your favorites in the comments.

Getting Started with TypeScript: Type Annotations & Type Inference (Part I)

youxufkhan — Mon, 08 Jul 2024 15:43:10 +0000

Type annotations and type inference are two different systems in typescript but in this post we will talk about them in parallel.

Type Annotations

Code we add to tell TypeScript what type of value a variable will refer to

We tell typescript the type

Type Inference

Typescript tries to figure out what type of value a variable refers to

Typescript guesses the type

The type annotation system is kind of at odds with the type inference, so we are going to first understand type annotations and then come along and understand how type inference comes into play.

To make things a little bit more complicated, know that these two different features apply slightly differently to

Variables
Functions
Objects

Let's first talk about how they are applied to Variables, By Examples

let apples: number = 5;

In this simple example :number is type annotation.

If we were to set the value of apples to a boolean we would get an error in this case.

const apples: number = true;

Error: Type 'boolean' is not assignable to type 'number'.ts(2322)

Similarly,

let apples: number = 5;
apples = 'asdas

Type 'string' is not assignable to type 'number'.ts(2322)

let banana = 5; // type inference
let banana: number // type annotation
let banana: number = 5 // type annotation

If the declaration and initialization are on the same line without type annotation, typescript will figure out the type of variable for us

[Variable declaration]      [Variable initialization]
     const        color   =               red

Objects:

//Type inference
 let point = {
     x:10,
     y:20
 }

// Type annotation
let point: { x: number, y: number } = {
    x: 10,
    y: 20
}

Functions:

//Type inference
const logNumber = (i) => {
    console.log(i)
}

// Type annotation
const logNumber: (i: number) => void = (i: number) => { // [(i: number) => void] is the annotation here
    console.log(i)
}

When to use annotations with functions

Function that returns 'any' type

const json = '{"x": 10, "y": 20}'
const coordinates = JSON.parse(json)
console.log(coordinates) // {x:10, y:20}

We need to understand how JSON.parse works for different values

Passed Value	JSON.parse()	Return Value
'false'	JSON.parse()	boolean
'4'	JSON.parse()	number
'{"value:5"}'	JSON.parse()	{value:name}
'{"name":"alex"}'	JSON.parse()	{name:string}

Typscript decides to set return type to any, meaning it has no idea what type will be returned.

Why and when to use type annotation or type inference

Type inference

When we declare a variable on one line then initialize it later
When we want a variable to have a type that cant be inferred
When a function returns the 'any' type and we need to clarify the value

Type inference

Always
When we declare a variable on one line and initialize it later

Lets wrap the first part of type annotations and type inference in typescript. We will discuss it further in next post. 💯

Getting Started with TypeScript: Types

youxufkhan — Sun, 12 May 2024 19:57:20 +0000

Type

What is Type?

Easy way to refer to different properties + functions that a value has.

Let's learn from an example

"red"

What do you see above, it's a string. That's right. But also
It is a value that has all the properties + methods that we assume that a string has

Properties + Methods a 'string' has in JS

charAt(), charCodeAt(), concat(), includes(), endsWith(), indexOf(), lastlndexOf(), localeCompare(), match(), length and so on....

I hope you understand from the above example what a type is.

Categories of Types

In the world of typescript there are two different categories of types.

Primitive Types
Object Types

Primitive Types

Primitive types are all the basic types you might guess.

number
string
boolean
symbol
void
null
undefined

Object Types

These are any types you create or any other types that are built into language itself.

functions
classes
arrays
Objects

Why do we care about types?

Types are used by the Typescript Compiler to analyze our code for errors
Types allow other engineers to understand what values are flowing around our codebase

Examples of Types



const today = new Date();

I created a variable that is an instance of a Date object, if I hover of that variable my code editor will tell me the type of value this variable is pointing at.

const today: Date

Typescript can now use this information to decide what we can do with this variable. For example if we use this variable and put a dot at the end, I will see my autocomplete pop up here.

This is listing out all the different functions and properties a Date object has. Typescript knows that because it has internal definition of what a Date is.

Similarly if we try to reference a value that a doesn't exist in the Date object, we will immediately see an error.

Now lets create a plain JavaScript Object.



const person = {
    age: 20,
    getAge: function(): number {
        return this.age;
    }
}

If I hover over the variable now, it will show all the properties and the method the object has.

I hope by these examples you have the basic idea of types in TypeScript. We will discuss more about each of these in the later posts.

Getting Started with TypeScript: A Quick Introduction From JavaScript to TypeScript!

youxufkhan — Thu, 02 May 2024 17:29:08 +0000

As I dive into mastering TypeScript this month, I'll be sharing my journey here, keeping it concise and easy to follow. So, let's kick things off with the very basics. I'm assuming you have a basic grasp of JavaScript.

Here's a short JavaScript snippet to start with:

const axios = require('axios');

const url = 'https://jsonplaceholder.typicode.com/todos/1'

axios.get(url).then(response => {
    const todo = response.data
    const ID = todo.id
    const title = todo.title
    const completed = todo.completed
    console.log(`
        The todo with ID: ${ID}
        has a title of: ${title}
        is it finished?: ${completed}
    `);
})

Simple, right? This code just sends an HTTP request using axios and fetches a single todo object from the jsonplaceholder API.

Now, let's rewrite this in basic TypeScript. First, we can use ES6 module syntax to import axios:

import axios from 'axios'

Next, we'll define a type for the url variable:

const url:string = 'https://jsonplaceholder.typicode.com/todos/1'

Now, onto the main part of our code:

axios.get(url).then(response => {
    const todo = response.data as Todo
    const ID = todo.id
    const title = todo.title
    const completed = todo.completed
    console.log(`
        The todo with ID: ${ID}
        has a title of: ${title}
        is it finished?: ${completed}
    `);
})

Notice in the above snippet, we've assigned the response data to the todo variable but as Todo. You might be wondering, what's Todo? Well, here's where interfaces come into play. We'll explicitly define a Todo interface:

interface Todo {
    id: number;
    title: string;
    completed: Boolean
}

And that's it! Here's how it all looks finally in TypeScript.

import axios from 'axios';
const url:string = 'https://jsonplaceholder.typicode.com/todos/1'

interface Todo {
    id: number;
    title: string;
    completed: Boolean
}

axios.get(url).then(response => {
    const todo = response.data as Todo
    const ID = todo.id
    const title = todo.title
    const completed = todo.completed
    console.log(`
        The todo with ID: ${ID}
        has a title of: ${title}
        is it finished?: ${completed}
    `);
})

Before we wrap up, let's quickly highlight the core differences we introduced in the TypeScript version of our code.

Type Annotations: We added type annotations to variables, enhancing code clarity and catching potential errors early.

Interface Definition: Introducing the Todo interface allowed us to specify the structure of our data, promoting better code organization and type safety.

In this post, I started with a simple JavaScript snippet fetching data from an API using axios. Then, we gradually migrated it to TypeScript, introducing some of the basic syntax of TypeScript.

Don't worry if you don't understand some of the terminologies or concepts used here; this is just a short introduction post. In the next post, we'll dive into basic concepts and terminologies to ensure everyone's on the same page. Stay tuned for more TypeScript adventures!