James Kozlowski

The Setup

At work, I've been using Claude Code - it's solid and integrates well with our development workflow. But lately I've been playing around with opencode and honestly, it's been pretty impressive.

The Migration

I ported over most of my agents and skills from Claude Code to opencode. The process was smoother than I expected, and now I have a pretty similar setup running in both environments.

The Anthropic Situation

Here's where things got frustrating. Anthropic's Claude Code Max plans will NOT let you log in directly - you have to use an API key. And API usage adds up quickly. It's pricey for everyday use.

So at work, I've switched to OpenAI's Pro plan instead. They support direct login, it's more predictable in terms of cost, and honestly it's been working great for what I need.

Personal Use

For my personal projects, I'm on a basic Pro plan with OpenAI/GPT. Combined with OpenCode Zen (which gives pay-as-you-go access to different API models), I've got a solid setup that fills in the gaps. It's not perfect, but it's working nicely for side projects and experimenting.

The Verdict

Having multiple tools in the toolbox has been surprisingly useful. Each has its strengths, and being able to switch between them depending on the task is pretty powerful. Plus, having Zen as a backup when I need other models is clutch.

Overview

"Zero to Production in Rust" by Luca Palmieri is a hands-on guide to building production-ready Rust applications. It covers everything from project setup to deployment.

What I Liked

• Real-world examples using Actix-web
• Excellent coverage of error handling
• Practical testing strategies
• Database integration with SQLx

What Could Be Better

• Some sections feel rushed
• Would love more async deeper dives

Verdict

Highly recommended for intermediate Rust developers who want to build real systems. It's not a beginner book, but it fills a crucial gap in the Rust ecosystem.

Why These Books?

After having a programming background, I wanted to dive into Go. "Let's Go" was a great starting point. It starts slow but covers everything exceptionally well - from the basics to building real web applications.

What I Learned

• Go fundamentals done right
• Best practices for structuring Go projects
• Building RESTful APIs
• Working with databases (PostgreSQL)
• Middleware and authentication

The Author's Website

Alex Edwards maintains an excellent blog at alexedwards.net with tutorials and guides that complement the books perfectly.

Staying Up to Date

One thing I really appreciate is how Alex keeps the books current. When a new Go version drops, he updates the books and emails purchasers with the new version. That's dedication!

Verdict

If you're looking to learn Go, start here. "Let's Go" gets you building real applications, and "Let's Go Further" takes you to advanced territory.

The Problem with PRNGs

Pseudo-random number generators (PRNGs) are deterministic. Given the same seed, they'll produce the same sequence. For many applications, this is fine. But what if you want true randomness?

The Solution: Reddit as Entropy

I built an API that fetches the latest comments from Reddit, hashes them, and uses the hash as a seed. The idea is that the unpredictable nature of human comments provides true randomness.

Implementation

• Fetch trending posts from multiple subreddits
• Extract comment text and timestamps
• Hash the combined data using SHA-256
• Use the hash bytes to seed a cryptographically secure random number generator

Results

The API now serves random numbers to anyone who wants them. It's an interesting experiment in decentralized entropy!

Why Chip-8?

Chip-8 is often recommended as a first emulator project because it's simple enough to complete in a weekend, yet complex enough to teach you the fundamentals of emulation.

The Architecture

Chip-8 has 35 opcodes, 16 8-bit registers, and a simple memory model. The display is 64x32 pixels, and programs start at address 0x200.

Key Challenges

• Implementing the DXYN draw instruction (sprites, XOR rendering)
• Handling keyboard input and the waiting-for-key opcode
• Getting the timing right (Chip-8 runs at ~540Hz)

The Result

The finished emulator includes a built-in debugger with memory inspection, register viewing, and step-by-step execution. Check it out on GitHub!