Python on Ikwuka Okoye

Building Asteroids with Python and Pygame: From Game Idea to Playable System

Tue, 11 Aug 2026 00:00:00 +0000

Building Asteroids with Python and Pygame: From Game Idea to Playable System

Small games are deceptively useful engineering projects.

They may contain only a few objects on screen, but those objects introduce many of the same problems found in larger software systems: state management, object lifecycles, input handling, timing, rendering, collision detection, and the need to keep individual components understandable as the codebase grows.

The Asteroids project was built as an opportunity to explore those problems through a compact interactive system using Python and Pygame.

From Markdown to HTML: Designing the Static Site Generator Pipeline

Tue, 11 Aug 2026 00:00:00 +0000

From Markdown to HTML: Designing the Static Site Generator Pipeline

A static site generator is fundamentally a transformation system.

It takes source content, processes that content through a series of stages, and produces files that can be served directly to users.

For my static site generator, the core transformation looks like this:

Markdown
 ↓
Blocks
 ↓
Block Types
 ↓
Inline Text Nodes
 ↓
HTML Nodes
 ↓
HTML

The value of this architecture is not simply that it works.

Building a Static Site Generator in Python: From Markdown to HTML

Mon, 10 Aug 2026 00:00:00 +0000

Building a Static Site Generator in Python: From Markdown to HTML

A static site generator looks simple from the outside.

You write some Markdown, run a command, and HTML files appear in an output directory.

The interesting engineering work happens between those two points.

Building a static site generator from scratch is a useful exercise because it exposes several concepts that are normally hidden behind frameworks and libraries: parsing, intermediate representations, tree structures, rendering, filesystem operations, and deterministic builds.

Converting Markdown Blocks into Semantic HTML

Mon, 10 Aug 2026 00:00:00 +0000

Converting Markdown Blocks into Semantic HTML

Markdown documents are written as a continuous stream of text, but browsers consume structured HTML.

Bridging those two representations requires more than replacing a few characters.

A static site generator needs to understand the boundaries between blocks and determine what each block represents.

That was one of the central problems in my Static Site Generator project.

What Is a Markdown Block?

A block is a logical unit of Markdown content.

Parsing Markdown into an HTML Tree: Designing the Intermediate Representation

Mon, 10 Aug 2026 00:00:00 +0000

Parsing Markdown into an HTML Tree: Designing the Intermediate Representation

One of the easiest mistakes to make when building a Markdown-to-HTML converter is to think of the problem as string replacement.

Replace **text** with <strong>text</strong>.

Replace *text* with <em>text</em>.

Replace headings with <h1>.

At first, this seems sufficient.

It quickly becomes difficult once documents contain nested structures.

A more robust approach is to introduce an intermediate representation between Markdown and HTML.

Testing a Static Site Generator: Small Contracts, Reliable Output

Mon, 10 Aug 2026 00:00:00 +0000

Testing a Static Site Generator: Small Contracts, Reliable Output

A static site generator is a good example of a system where small bugs can propagate through multiple layers.

A mistake in Markdown parsing can eventually appear as malformed HTML.

A malformed text node can produce incorrect links.

A block-classification error can cause an entire section of a page to render incorrectly.

That makes testing especially important.

The solution is not necessarily hundreds of large end-to-end tests.

Building Reliable Tool Use into an AI Agent

Sun, 09 Aug 2026 00:00:00 +0000

Building Reliable Tool Use into an AI Agent

The moment an AI agent needs to interact with something outside the language model, tool use becomes central to its design.

A model can explain how to query a database.

It cannot query the database unless the surrounding application gives it a mechanism to do so.

That mechanism is the tool.

Why Tools Matter

A language model operates primarily through generated information.

Designing the Architecture of an AI Agent

Sun, 09 Aug 2026 00:00:00 +0000

Designing the Architecture of an AI Agent

Building an AI agent is very different from building a simple application that sends a prompt to a language model and displays the response.

A useful agent needs to do more than generate text. It needs to interpret a goal, decide what should happen next, use tools when necessary, maintain enough state to complete the task, observe the result, and recover when something goes wrong.

Making an AI Agent Reliable

Sun, 09 Aug 2026 00:00:00 +0000

Making an AI Agent Reliable

The most impressive AI agent demo can still be a poor piece of software.

A demonstration may work perfectly when the model responds as expected, every API is available, every tool succeeds, and the task is small.

Real systems are not that forgiving.

Models produce unexpected outputs.

Networks fail.

Tools time out.

External APIs change.

Users provide ambiguous instructions.

An agent that cannot handle these conditions is not reliable.

Managing Memory and State in an AI Agent

Sun, 09 Aug 2026 00:00:00 +0000

Managing Memory and State in an AI Agent

An AI agent becomes significantly more useful when it can maintain context across multiple steps.

But “memory” is often used too loosely.

For an engineer, it is more useful to distinguish between the different kinds of information an agent needs to retain.

Some information belongs to the current execution.

Some belongs to the conversation.

Some may need to persist beyond the current session.

What Building an AI Agent Taught Me About Backend Engineering

Sun, 09 Aug 2026 00:00:00 +0000

What Building an AI Agent Taught Me About Backend Engineering

Building an AI agent initially appears to be an exercise in working with language models.

In practice, much of the work quickly becomes familiar backend engineering.

Requests need validation.

State needs to be managed.

External services need timeouts.

Failures need to be handled.

Operations need to be observable.

Components need clear boundaries.

The language model adds a new dimension, but many of the underlying engineering principles remain the same.

Building OpsPilot: Why I Started a DevOps Platform

Tue, 04 Aug 2026 00:00:00 +0000

OpsPilot started with a simple question: what would happen if I built the operational tooling I kept wishing I had?

As I continued working across backend engineering, DevOps, and cloud-native infrastructure, I found myself repeatedly dealing with the same categories of operational work. Instead of treating those tasks as isolated scripts and commands, I wanted to explore what it would look like to bring them together into a coherent engineering platform.

Asteroids

Sat, 18 Jul 2026 00:00:00 +0000

Overview

Asteroids is a classic arcade-style space shooter rebuilt from the ground up in Python using Pygame.

The project focuses on the fundamentals behind interactive 2D applications: managing a real-time game loop, responding to user input, updating object state, detecting collisions, and rendering a constantly changing scene at a consistent frame rate.

Rather than relying on a game engine to handle the underlying mechanics, the project provides a practical exercise in understanding how those systems fit together.

Static Site Generator

Thu, 16 Jul 2026 00:00:00 +0000

A Python static-site generator exploring parsing, AST-like structures, Markdown transformation, HTML generation, and clean software architecture.

BookBot

Tue, 14 Jul 2026 00:00:00 +0000

A Python CLI project focused on file processing, text analysis, dictionaries, iteration, and clean command-line application structure.

AI Agent

Fri, 10 Jul 2026 00:00:00 +0000

Overview

AI Coding Agent is a command-line developer tool built to explore how modern AI agents can reason about software projects and assist with real-world engineering workflows.

The project focuses on the practical foundations of an AI-powered coding assistant: understanding a repository, processing developer instructions, reasoning about available context, and producing useful actions or code changes.

Rather than treating an LLM as a simple text-generation interface, the project explores the architecture required to turn language models into practical software-engineering agents.