Hello, World

2026-03-25T00:00:00Z

Every blog starts somewhere. This one starts here.

I’ve had half-written posts sitting in a notes app for longer than I’d like to admit. The plan was always to find the perfect platform, the perfect design, the perfect time. None of those things materialized. So instead I built a site and wrote a post.

Why a blog?

Writing is thinking. I write to understand things better — to turn a vague feeling that I understand something into proof that I do. If someone else finds it useful, that’s a bonus.

I’ll be writing about:

Code — things I’ve built, patterns I’ve found useful, tools I reach for
Developer tooling — editors, terminals, workflows
Projects — what I’m building and what I’ve learned along the way

The stack

This site is built with Eleventy and Tailwind CSS. The design is intentionally IDE-like — Catppuccin palette, monospace fonts, tab navigation. I spend most of my day in a code editor, so it felt right.

Here’s the basic Eleventy config structure I’m using:

module.exports = function(eleventyConfig) {
  eleventyConfig.addPlugin(syntaxHighlight);

  eleventyConfig.addFilter("readingTime", (content) => {
    const words = content.replace(/<[^>]+>/g, '').split(/\s+/).length;
    return `${Math.ceil(words / 200)} min read`;
  });

  return {
    dir: { input: "src", output: "_site" }
  };
};

And the Catppuccin variables that drive the theming:

:root {
  /* Catppuccin Latte — light */
  --ctp-mauve: #8839ef;
  --ctp-blue:  #1e66f5;
  --ctp-base:  #eff1f5;
}

.dark {
  /* Catppuccin Mocha — dark */
  --ctp-mauve: #cba6f7;
  --ctp-blue:  #89b4fa;
  --ctp-base:  #1e1e2e;
}

Swapping the palette is as simple as changing those hex values.

What’s next

More posts. More projects. We’ll see where it goes.

Building a CLI Tool in Go

2026-03-20T00:00:00Z

I recently needed a small CLI tool to automate something I was doing manually every day. Instead of reaching for a shell script, I wrote it in Go. Here’s what I learned.

Why Go for CLIs?

A few reasons:

Single binary — no runtime, no dependencies, just copy and run
Fast startup — unlike Python or Node, there’s no interpreter warm-up
Good standard library — flag, os, io get you a long way

The tradeoff is verbosity, but for a tool I’ll use daily, that’s fine.

Project structure

mytool/
├── main.go
├── cmd/
│   ├── root.go
│   └── run.go
└── go.mod

For small tools I skip cobra and just use flag from stdlib. For anything with subcommands, cobra is worth the dependency.

Parsing flags

package main

import (
    "flag"
    "fmt"
    "os"
)

func main() {
    verbose := flag.Bool("verbose", false, "Enable verbose output")
    output  := flag.String("out", "stdout", "Output destination")
    flag.Parse()

    args := flag.Args()
    if len(args) == 0 {
        fmt.Fprintln(os.Stderr, "error: no input provided")
        os.Exit(1)
    }

    if *verbose {
        fmt.Printf("output: %s\n", *output)
        fmt.Printf("args:   %v\n", args)
    }

    // ... do the thing
}

Reading from stdin

One pattern I use constantly — accept input from a file argument or stdin:

func getInput(args []string) (io.Reader, error) {
    if len(args) > 0 {
        return os.Open(args[0])
    }
    // Check if stdin has data
    stat, _ := os.Stdin.Stat()
    if (stat.Mode() & os.ModeCharDevice) == 0 {
        return os.Stdin, nil
    }
    return nil, fmt.Errorf("no input: provide a file or pipe data via stdin")
}

This makes the tool composable — it plays nicely with pipes and shell scripts.

Distributing the binary

For personal tools, go install is enough:

go install github.com/you/mytool@latest

For something others will use, goreleaser handles cross-compilation and GitHub releases with minimal config.

Takeaways

The standard library gets you 80% of the way. Reach for cobra when you need subcommands. Build tools that pipe — stdin/stdout composition is underrated.

Ali Mohamud

Hello, World

Building a CLI Tool in Go