A meta-runtime for building domain-specific, reactive execution engines.

Just released version 0.3.0, with a cool new demo!

Demo: https://github.com/creact-labs/ai-powered-aws-website-generator
CReact: https://github.com/creact-labs/creact

Website: https://creact-labs.github.io/creact/

I Built a YouTube Dislike Viewer with Next.js 16

Ever since YouTube removed the public dislike count, it’s been harder to judge video quality at a glance. So I built a
simple tool to bring it back.

Live site: https://www.youtubedislikeviewer.shop

What It Does

Paste any YouTube URL or video ID, and instantly see:

• 👍 Likes & 👎 Dislikes
• 📊 Like/Dislike ratio bar
• 👁 View count & rating
• 🕐 Search history (stored locally)

Tech Stack

• Next.js 16 (App Router + Turbopack)
• React 19 + TypeScript 5.9
• Tailwind CSS 4
• Return YouTube Dislike API (community-driven dislike data)

Key Design Decisions

API Proxy with Caching

Instead of calling the dislike API directly from the client, I set up a server-side proxy route at /api/dislike. This
lets me add cache headers (s-maxage=300, stale-while-revalidate=600) so repeated lookups for the same video are fast
and cheap.

// app/api/dislike/route.ts (simplified)
export async function GET(request: Request) {
const videoId = new URL(request.url).searchParams.get(‘videoId’);
const res = await fetch(
https://returnyoutubedislikeapi.com/votes?videoId=${videoId}
);
const data = await res.json();
return Response.json(data, {
headers: {
‘Cache-Control’: ‘public, s-maxage=300, stale-while-revalidate=600’,
},
});
}

Robust URL Parsing

YouTube URLs come in many flavors — youtube.com/watch?v=, youtu.be/, /embed/, or just a raw 11-character ID. A single
extraction function handles all of them with regex.

Thumbnail Fallback

Not every video has a maxresdefault thumbnail. The component tries the highest quality first and falls back to
hqdefault on error — no broken images.

What I Learned

1. Next.js 16 App Router is mature and pleasant to work with. The server/client component split feels natural once you
   get used to it.
2. Caching at the edge with simple Cache-Control headers goes a long way — no Redis needed for a project this size.
3. localStorage is still a perfectly fine solution for lightweight client-side persistence like search history.

Try It Out

Check it out at https://www.youtubedislikeviewer.shop and let me know what you think!

I like Python. A lot, actually. It is hard to argue against it: Python dominates data science, AI, and a large part of backend development.

But I am also a C++ developer, and over the last year I built my own interpreter: jdBasic.

Not as a Python replacement, but as an experiment in a different direction.

The question behind it was simple:

What happens if you design a language and an interpreter purely around reducing friction during everyday development and experimentation?

This article is not about hype. It is about very practical trade-offs.

Motivation: The Hidden Cost of “Just Import a Library”

Python’s strength is its ecosystem. At the same time, that ecosystem introduces a constant overhead:

• virtual environments
• package management
• imports for even small tasks
• tooling setup before you can actually think

That cost is usually acceptable. Sometimes it is not.

jdBasic explores a different idea:

Bake common, complex operations directly into the language instead of outsourcing them to libraries.

1. The “Always-Open” Utility Console

One of the most common interruptions in development is context switching.

• open a terminal
• start a REPL
• import something
• run a quick check
• close everything again

jdBasic is small and fast enough that I simply keep it open all day. It works like a scratchpad.

Need to check if a text block fits in a 500-char database field?

? LEN("paste the massive string here...")

Quick hex arithmetic:

? $FF * 2

No setup, no imports, no ceremony.

2. Unique Random Numbers Without Loops

Generating something like “6 out of 49” sounds trivial, but in many languages it immediately leads to loops or helper libraries.

jdBasic supports APL-style vector operations.
That means you can treat numbers like a deck of cards:

1. generate 1..49
2. shuffle the sequence
3. take the first 6 elements

' IOTA(49, 1) generates 1..49, SHUFFLE randomizes, TAKE gets the first 6
PRINT TAKE(6, SHUFFLE(IOTA(49, 1)))
' Output: [12 4 49 33 1 18]

No loops, no duplicate checks, no additional code.

3. ASCII Visualization in a Single Statement

In Python, visualization usually means installing and configuring libraries like matplotlib or pandas.

jdBasic takes a different approach:
2D arrays and string matrices are native data types.

This makes it possible to calculate and render ASCII charts directly in the console.

The following example is a complete biorhythm chart (physical, emotional, intellectual) rendered in one statement:

' One-liner Biorhythm Chart
BD="1967-10-21":W=41:H=21:D=DATEDIFF("D",CVDATE(BD),NOW()):X=D-W/2+IOTA(W):C=RESHAPE([" "],[H,W]):PY=INT((SIN(2*PI*X/23)+1)*((H-1)/2)):EY=INT((SIN(2*PI*X/28)+1)*((H-1)/2)):IY=INT((SIN(2*PI*X/33)+1)*((H-1)/2)):C[H/2,IOTA(W)-1]="-":C[IOTA(H)-1,INT(W/2)]="|":C[PY,IOTA(W)-1]="P":C[EY,IOTA(W)-1]="E":C[IY,IOTA(W)-1]="I":PRINT "Biorhythm for " + BD:PRINT FRMV$(C)

It calculates the sine waves for three different cycles, maps them to a 2D grid, overlays axes, and prints the result—all without a single external library or loop.

It returns to the roots of the 8-bit era: the computer is a calculator that is always ready.

4. Persistent Workspaces

In Python, a REPL session is temporary.
Once you close it, everything is gone unless you explicitly serialize your state.

jdBasic reintroduces an old idea: persistent workspaces.

SAVEWS "debugging_session"

The next morning, I open my console and type:

LOADWS "debugging_session"

Variables, functions, objects, history – everything is restored.
I use this constantly for long-running investigations:

• one workspace for database analysis
• one for AI experiments
• one for automation tasks

5. Working with Corporate Data (MS Access, ADODB)

Enterprise environments often come with “unfashionable” data sources.
MS Access databases are a good example.

In Python, this usually means:

• ODBC drivers
• pyodbc
• platform-specific setup

jdBasic uses COM and ADODB directly, without external libraries.

I keep a workspace called “SQL_Console” that contains a simple 150-line script (acct.jdb). It wraps the complexity of ADO into a simple REPL.

The Implementation (Simplified):

' Connect to Access without external libraries
conn = CREATEOBJECT("ADODB.Connection")
conn.Open("Provider=Microsoft.ACE.OLEDB.12.0;Data Source=Orders.accdb")

' Execute SQL and get results
rs = CREATEOBJECT("ADODB.Recordset")
rs.Open("SELECT * FROM Orders", conn)

' Print results
DO WHILE NOT rs.EOF
    PRINT rs.Fields("Customer").Value; " | "; rs.Fields("Amount").Value
    rs.MoveNext()
LOOP

Because I save this in a workspace, I never re-type the connection string. I just load SQL_Console and fire queries:

ExecuteSQL "SELECT * FROM Users WHERE ID=5"

It returns a formatted Map or Array immediately.
Because this lives in a workspace, I never reconfigure it.
I just load it and run queries.

6. Desktop Automation: Controlling Windows Native Apps

Automating Windows applications used to be easy in the VB6 era.
In Python, it is possible, but often feels bolted on.

In jdBasic, COM automation is a core language feature.

' Launching Microsoft Word...
wordApp = CREATEOBJECT("Word.Application")
wordApp.Visible = TRUE
doc = wordApp.Documents.Add()

' Select text and format it via COM
sel = wordApp.Selection
sel.Font.Name = "Segoe UI"
sel.Style = -2 ' wdStyleHeading1
sel.TypeText "My Generated Doc"

7. Vector Math Without NumPy

In Python, element-wise math requires NumPy.

Python:

import numpy as np
V = np.array([10, 20, 30, 40])
print(V * 2)

jdBasic:
In jdBasic, arrays are first-class citizens. The interpreter knows how to handle math on collections natively.

V = [10, 20, 30, 40]
PRINT "V * 2: "; V * 2
' Output: [20 40 60 80]

There are no imports. No pip install. The interpreter understands what you mean.

8. Learning AI with Transparent Tensors

For production AI, Python frameworks are unbeatable.

For learning how things actually work internally, they can be opaque.

jdBasic has a built-in Tensor type with automatic differentiation.
Gradients are explicit and inspectable.

' Built-in Autodiff
A = TENSOR.FROM([[1, 2], [3, 4]])
B = TENSOR.FROM([[5, 6], [7, 8]])

' Matrix Multiplication
C = TENSOR.MATMUL(A, B)

' Calculate Gradients
TENSOR.BACKWARD C
PRINT "Gradient of A:"; TENSOR.TOARRAY(A.grad)

This is not about performance.
It is about understanding.

9. Micro-Services Without a Framework

In Python, even a small HTTP API usually involves a framework.

jdBasic includes an HTTP server as a language feature.

FUNC HandleApi(request)
  response = {
    "status": "ok",
    "server_time": NOW()
  }
  RETURN response
ENDFUNC

HTTP.SERVER.ON_POST "/api/info", "HandleApi"
HTTP.SERVER.START(8080)

Define a function, return a map, get JSON.

The Verdict: Ecosystem vs. Immediacy

This is not a “Python vs. BASIC” argument.
It is about choosing where you want to pay the cost.

For production systems and large teams: Python is the right choice.

For an always-on, persistent, low-friction development console:
sometimes, my jdBasic interpreter is surprisingly effective.

Basic never really disappeared 🙂

You can explore the interpreter’s source code, dive into the documentation, and see more examples over at the official GitHub repository: jdBasic

You can try the main features online at: jdBasic

If you use Claude Code (Anthropic’s official CLI), you’ve probably experienced this frustration:

You’re deep into a coding session on your work laptop. Claude remembers your project context, your preferences, your conversation history. Everything is flowing perfectly.

Then you switch to your personal MacBook… and it’s all gone.

Claude doesn’t know what you were working on. Your custom agents? Gone. Your project memory? Vanished. You have to start from scratch.

I built Claude Sync to fix this.

What is Claude Sync?

Claude Sync is an open-source CLI tool that synchronizes your ~/.claude directory across devices using encrypted cloud storage.

Key Features:

• 🔐 End-to-end encryption – Files encrypted with age before upload
• 🔑 Passphrase-based keys – Same passphrase = same key on any device
• ☁️ Multi-cloud support – Cloudflare R2, AWS S3, or Google Cloud Storage
• 🆓 Free tier friendly – Works within free storage limits
• ⚡ Simple CLI – Just push and pull

# That's literally it
claude-sync push   # Upload changes
claude-sync pull   # Download changes

What Gets Synced?

Everything Claude Code stores locally:

Quick Start Guide

Install Claude Sync

Choose your preferred method:

# npm (recommended - works everywhere)
npm install -g @tawandotorg/claude-sync

# Or use npx for one-time use
npx @tawandotorg/claude-sync init

Daily Workflow

Once set up, your workflow is simple:

# Start of day (or when switching devices)
claude-sync pull

# ... use Claude Code normally ...

# End of day (or before switching devices)
claude-sync push

Pro Tip: Automate It

Add to your ~/.zshrc or ~/.bashrc:

# Auto-pull on shell start
if command -v claude-sync &> /dev/null; then
  claude-sync pull -q &
fi

# Auto-push on shell exit
trap 'claude-sync push -q' EXIT

Get Started

npm install -g @tawandotorg/claude-sync
claude-sync init
claude-sync push

GitHub: github.com/tawanorg/claude-sync

Documentation: tawanorg.github.io/claude-sync

Feedback Welcome!

This is an open-source project. If you:

• Find bugs 🐛
• Have feature ideas 💡
• Want to contribute 🤝

Open an issue or PR on GitHub!

Have you struggled with syncing Claude Code across devices? What solutions have you tried? Let me know in the comments!

“I’m already paying for one AI coding tool. Should I switch?”

This is the question I keep hearing from developers. GitHub Copilot was first. Cursor disrupted everything. And Cody quietly became the best option nobody talks about.

After using all three on real projects — React apps, Python backends, infrastructure scripts — I have strong opinions.

Spoiler: The best choice depends on one question: How do you work?

TL;DR — The Quick Verdict

For staying in your current IDE: GitHub Copilot wins. Works everywhere.

For maximum AI power: Cursor wins. Agent mode is unmatched.

For large codebase understanding: Cody wins. Sourcegraph’s search is killer.

For price-conscious developers: Copilot Free. 12,000 completions/month free.

For teams on GitHub: Copilot. Native integration matters.

My pick: Cursor for serious development work, Copilot Free as my backup when I’m on a random machine. Cody if you work on massive enterprise codebases.

Quick Comparison (2026)

The 2026 Landscape: What’s Changed

The AI coding space has exploded. Here’s what matters:

GitHub Copilot’s big moves:

• Free tier launched — 12,000 completions/month, limited chat
• Model choice — Pick between GPT-4o, Claude 3.5 Sonnet, or o1
• Copilot Edits — Multi-file editing (finally)
• Workspace Agent — Better codebase understanding
• Still works everywhere: VS Code, JetBrains, Neovim, Visual Studio

Cursor’s rise:

• $9 billion valuation — Not a toy anymore
• Agent mode — Run commands, modify files, fix its own errors
• Composer — Multi-file generation that actually works
• Tab prediction — Predicts where you’ll edit next
• Became the default recommendation for “best AI coding tool”

Cody’s quiet revolution:

• Sourcegraph integration — Unmatched codebase understanding
• Generous free tier — Unlimited autocomplete, 200 chats/month
• Multiple LLMs — Claude 3.5, GPT-4o, Gemini 2.0 Flash
• Pro tier at $9/month — Cheapest paid option
• Works in VS Code, JetBrains, Neovim (not locked to one IDE)

Where GitHub Copilot Wins 🏆

1. It Works Everywhere

This is Copilot’s superpower. It’s an extension, not an IDE.

Use it in:

• VS Code
• JetBrains (IntelliJ, PyCharm, WebStorm, etc.)
• Neovim
• Visual Studio
• The GitHub website
• GitHub Mobile

Cursor and Cody require you to either switch IDEs or install specific extensions. Copilot follows you everywhere.

If you’ve spent years customizing your IDE setup, Copilot lets you keep it. That’s worth a lot.

2. The Free Tier is Actually Useful

12,000 completions per month. Limited chat. No credit card required.

For hobbyists, students, and even many professionals — this is enough. You’re not hitting that limit unless you’re accepting completions all day every day.

The free tier math: 12,000 ÷ 22 working days = ~545 completions per day. That’s plenty for most developers.

Cody’s free tier is generous for chat (200/month) but that’s different from inline completions. Cursor’s free tier (2,000 completions) runs out fast.

3. GitHub Integration

If your team lives on GitHub:

• Copilot understands your repos natively
• Pull request summaries and reviews
• Issue understanding
• Workspace context from your GitHub projects

For teams already paying for GitHub Enterprise, adding Copilot Business is a no-brainer upsell. It’s designed to work together.

4. Model Flexibility

Copilot now lets you choose your model:

• GPT-4o — Fast, reliable default
• Claude 3.5 Sonnet — Better at complex reasoning
• o1 — For hard problems that need deeper thinking

Most tools lock you to one model. Copilot gives you options within the same subscription.

5. The Safe, Conservative Choice

Copilot has been around longest. It’s stable. It’s backed by Microsoft/GitHub. It’s not going anywhere.

For enterprises worried about vendor risk, Copilot is the “nobody got fired for buying IBM” option.

Where Cursor Wins 🏆

1. Agent Mode (The Killer Feature)

Cursor’s agent can:

• Run terminal commands
• Read and modify files across your project
• Do semantic code search
• Fix its own mistakes by running tests

This isn’t “generate code and paste it.” This is an AI that can actually DO things.

Real example: “Add authentication to this Express app.”

Copilot will generate some code in your current file. Cursor Agent will create the middleware file, update your routes, add environment variables, create the database migration, and test that it works.

That’s a fundamentally different level of capability.

2. Composer — Multi-File Generation That Works

Describe what you want in natural language. Cursor generates coherent code across multiple files simultaneously.

Other tools have tried this (Copilot Edits, Cody’s edit mode). Cursor’s implementation is the most reliable. It understands how your files relate to each other and generates code that actually fits together.

3. Project-Wide Context

Cursor doesn’t just see your current file. It understands your entire codebase:

• Your folder structure
• Your naming conventions
• Your existing patterns
• Related files and imports

When you ask it to add a feature, it writes code that matches your style. That’s the difference between “AI-generated code” and “code that fits your project.”

4. Tab Prediction

This sounds minor but changes how you code. Cursor predicts not just what you’ll type, but where you’ll edit next.

Finish a function? Tab. Cursor jumps to where you probably need to add the import statement. Accept it. Tab again. Cursor jumps to the test file.

It’s subtle until you use it, then you feel crippled without it.

5. The Developer’s Choice

Cursor is what developers recommend to each other. Check any Reddit thread, any Hacker News discussion, any coding Discord. The consensus is clear: if you want the best AI coding experience and don’t mind switching editors, Cursor is it.

📬 Want more AI coding insights? Get weekly tool reviews and developer tips — subscribe to the newsletter.

Where Cody Wins 🏆

1. Large Codebase Understanding (Sourcegraph’s Secret Weapon)

Cody is built by Sourcegraph — the company that invented universal code search. That matters.

When you connect Cody to your repositories, it builds a semantic understanding of your entire codebase. Not just your current project — your whole organization’s code.

This changes everything for enterprise developers:

• “How does this microservice communicate with that one?”
• “Where is this deprecated function still being used?”
• “Show me all the places we handle authentication”

Cody can answer these across repositories. Copilot and Cursor are limited to your current project.

2. The Price is Right

Cody Pro at $9/month is the cheapest paid option. You get unlimited completions, 1000 chat messages, and access to multiple premium models.

For budget-conscious developers who want more than free tiers offer, Cody is compelling.

3. IDE Flexibility (Without the Copilot Lock)

Unlike Cursor (which IS an IDE), Cody works as an extension:

• VS Code
• JetBrains (all IDEs)
• Neovim

You keep your existing setup. You don’t have to leave your carefully configured PyCharm or WebStorm.

This is Copilot’s strength too — but Cody often has better codebase understanding at a lower price.

4. Enterprise Code Intelligence

For organizations with sprawling codebases across multiple repositories, Cody + Sourcegraph is unmatched:

• Cross-repository search and understanding
• Batch changes across many repos
• Code navigation that actually works at scale
• Understanding of how code connects across microservices

If you work at a company with 500+ repos, ask your platform team about Sourcegraph. Cody is the AI layer on top of genuinely powerful infrastructure.

5. Model Variety on Free Tier

Even free Cody users get:

• Claude 3.5 Sonnet
• Claude 3.5 Haiku
• Gemini 2.0 Flash
• GPT-4o-mini

That’s legitimate model choice without paying anything. Copilot Free locks you to a single model. Cursor Free is heavily limited.

Head-to-Head: Key Comparisons

Inline Completions

Winner: Copilot for raw speed. Cursor for quality.

Multi-File Editing

Winner: Cursor Composer. More capable, more reliable.

Agent/Autonomous Work

Winner: Cursor, by a mile. Agent mode is the future.

Codebase Understanding

Winner: Cody for enterprise. Cursor for local projects.

Pricing Deep Dive

Monthly Costs

What You Get at Each Tier

Free Tier Comparison:

• Copilot: Most generous for completions (12K/month)
• Cursor: Most limited (2K completions burn fast)
• Cody: Best chat limits (200/month), unlimited autocomplete

Individual/Pro Tier:

• Copilot ($10): Unlimited completions, full chat, model choice
• Cursor ($20): Composer, Agent mode, project context
• Cody ($9): 1000 chats, premium models, Sourcegraph features

Value Ranking

1. Best free: Copilot Free (if completions matter most)
2. Best budget paid: Cody Pro at $9/month
3. Best power-user: Cursor Pro at $20/month
4. Best for teams: Copilot Business at $19/user/month (GitHub integration)

Decision Matrix

The Honest Recommendation

All three are excellent. You’ll be more productive with any of them.

Get GitHub Copilot if:

• You use multiple IDEs (especially JetBrains)
• Your team is on GitHub and wants native integration
• You want the safe, established choice
• The free tier is enough for you

Get Cursor if:

• You’re a power user who wants maximum AI capability
• Agent mode and Composer appeal to you
• You’re willing to use a new IDE (it’s basically VS Code)
• You’re doing serious full-stack development

Get Cody if:

• You work on large enterprise codebases
• Cross-repository understanding matters
• You want paid features at the lowest price
• You prefer staying in JetBrains or existing IDE

The hybrid approach: Start with Copilot Free. If you hit limits or want more power, try Cursor Pro for a month. If you work on enterprise-scale code, evaluate Cody.

What I Actually Use

Daily driver: Cursor Pro. The Composer and Agent mode have genuinely changed how I build features. Worth $20/month.

Backup: Copilot Free installed everywhere. When I’m on a coworker’s machine or a server, it’s there.

For work projects: We use Copilot Business because the team is already on GitHub Enterprise and the integration is seamless.

The reality? Pick one and actually use it. The tool matters less than building the habit of working with AI assistance. If you want the latest on how these tools leverage MCP for deeper integrations, our best MCP servers guide covers what’s worth installing.

For a broader overview of all AI coding assistants including Claude Code and Windsurf, see our best AI coding assistants 2026 guide or the 7 best AI coding assistants ranked. Wondering which underlying AI model is best for coding? Our Claude vs GPT-4 for coding guide breaks it down. For a focused comparison of Cursor as an editor vs VS Code, check our Cursor vs VS Code guide. And if you want to try OpenAI’s agentic approach, read our Codex macOS app review.

📬 Get weekly AI tool reviews and comparisons delivered to your inbox — subscribe to the AristoAIStack newsletter.

Keep Reading

• 7 Best AI Coding Assistants Ranked
• Cursor vs GitHub Copilot 2026
• Cursor vs VS Code: Which AI Editor?
• Claude vs GPT-4 for Coding
• OpenAI Codex macOS App Review
• AI Coding Agents: Cursor vs Windsurf vs Claude Code vs Codex

Last updated: February 2026