DEV Community: Amine Amine

Why Simplicity Wins in Software Engineering

Amine Amine — Tue, 27 Oct 2026 05:09:26 +0000

Every software engineer has faced it: the pull toward complexity. A new abstraction layer here, a design pattern there, a framework on top of a framework. Before you know it, a feature that should take an afternoon takes a sprint.

The Complexity Tax

Complexity is a silent tax on every team. It slows onboarding, increases bugs, and makes refactoring feel like defusing a bomb. The most impactful engineers I've worked with aren't the ones who write the cleverest code — they're the ones who write code that anyone can understand.

Three Principles

Over the years, I've distilled my approach into three principles:

1. Delete before you add. The best code is no code. Before writing a new utility, check if the problem can be solved by removing something.

2. Name things for the next reader. A variable called userEmailVerificationStatus is better than s. Verbosity in naming is not the same as verbosity in code.

3. Optimize for change. Requirements will shift. Write code that's easy to modify, not code that's "perfect" for today's spec.

Where SimpleCode Came From

SimpleCode started as a personal experiment: what if building a website were as simple as describing it? No boilerplate, no configuration, no templates to wrestle with. Just tell the AI what you want, and it builds it.

That builder is still in the workshop and not ready for real users yet. Holding it back is the same principle at work: a feature earns its place by making things simpler, not by existing. In the meantime, simplecode.ca is where I try these ideas in public.

The Takeaway

Simplicity isn't the absence of features. It's the result of ruthless prioritization. Every line of code is a liability. Every abstraction is a bet that you'll need it again. Make those bets wisely.

Originally published on simplecode.ca.

Building a K Command Palette (and a Fake Terminal) for My Portfolio

Amine Amine — Tue, 27 Oct 2026 05:00:02 +0000

Press ⌘K (or Ctrl+K) anywhere on my site and you get a search box that jumps to any page, case study, game, blog post or Dota 2 hero. Press ~ and you get a terminal. Neither is essential. Both are the kind of detail that makes a developer's site feel like it was made by a developer.

Here's how they're built, and the few decisions that kept them simple.

Logic first, UI second

Both features are mostly logic, so I wrote the logic as pure functions with no React involved:

buildItems(posts, heroes, work) returns a flat list of { group, label, url, keywords };
filterItems(items, query) ranks them;
runCommand(input) returns { lines, action } for the terminal, where action is "navigate", "clear" or "exit";
complete(input) does tab completion.

The React components only render state and call these. That made them trivial to smoke-test: "typing wraith ranks Wraith King first", "cd blog/ goes to the blog", "c + Tab doesn't complete, because it's ambiguous".

Ranking without a fuzzy-search library

Fuzzy matching libraries are great, but for a hundred or so items a tiny score does the job. For each word you type:

a match at the start of the label scores 0 (best);
a match at the start of any word in the label scores 1;
a match anywhere in the label scores 2;
a match in the group or keywords scores 3;
no match anywhere, and the item is out.

Then sort by score, keeping the original order for ties. Keywords do the quiet work: "resume" finds the Experience section, and "hire" finds the contact page.

Don't load what nobody asked for

Dota has 120+ heroes, and putting all of them in every page's HTML would be wasteful. The palette fetches hero names the first time someone opens it, from an endpoint that's already cached for an hour. When the palette is empty, heroes stay hidden so the list starts with pages, not a wall of hero names.

The terminal

It's a switch statement with personality. help, whoami, ls projects, cat resume, cd contact and play chess all do something real. sudo tells you that simplicity is not negotiable, and vim reassures you that exit works here. Arrow keys walk your history, Tab completes, and Ctrl+L clears.

It uses the site's dark theme tokens, so it looks right without any one-off colours.

Respecting the person typing

I record anonymous usage events to see whether people actually use this. For the terminal, I only store the command word, and only if it's a command I know. Anything else is recorded as other. If someone types a sentence into a fake shell, it stays in their browser.

Try it

Open simplecode.ca, press ⌘K and type chess, or press ~ and type help. If you find a command I should add, tell me.

Originally published on simplecode.ca.

Verifying Every Chess Puzzle on My Home Page with a Tiny Solver

Amine Amine — Tue, 27 Oct 2026 04:56:59 +0000

My home page opens with a chess puzzle: White to play, mate in 2. It's the first thing visitors see, so it can't be wrong. A puzzle with two solutions, or one that's secretly a mate in 1, makes the whole site look sloppy.

I didn't want to check positions by hand, so I made the computer do it.

The definition, written as code

A mate-in-2 puzzle has exactly one first move for White such that, whatever Black replies, White can then deliver checkmate. Written down, that's three small functions on top of the chess engine that already powers Chess Master:

export function isCheckmate(pos: ChessPosition): boolean {
  return generateLegalMoves(pos).length === 0 && isInCheck(pos, pos.turn);
}

/** After White's first move: does every Black reply allow mate in one? */
export function forcesMateInOne(pos: ChessPosition): boolean {
  if (isCheckmate(pos)) return true;
  const replies = generateLegalMoves(pos);
  if (replies.length === 0) return false; // stalemate
  return replies.every((reply) => {
    const after = makeMove(pos, reply);
    return generateLegalMoves(after).some((m) => isCheckmate(makeMove(after, m)));
  });
}

A smoke test then checks every puzzle in the list:

it's White to move;
no legal move is an immediate checkmate (otherwise it's really a mate in 1);
exactly one legal move passes forcesMateInOne.

It's brute force, and that's fine. Puzzle positions are small: a few dozen first moves, a few dozen replies, a few dozen follow-ups. All 35 puzzles verify in about three seconds. In the browser, the same check runs when you make a move and takes around 2ms.

There's a nice side effect: the UI never compares your move against a stored answer. It asks the engine whether your move works. If a position ever had a second solution, it would still accept it.

Getting real puzzles, without downloading 300MB

Hand-made positions look artificial, so I wanted positions from real games. The Lichess puzzle database is released under CC0 and tags puzzles with themes like mateIn2. The catch is size: around 300MB compressed, millions of rows.

I only needed a few hundred candidates, so I streamed it and stopped early:

curl -s https://database.lichess.org/lichess_db_puzzle.csv.zst \
  | zstd -dc | grep -m 600 mateIn2 > mate2.csv

grep -m 600 exits after 600 matches, which closes the pipe, which stops the download. A few seconds instead of a few minutes.

Then a selection script:

Replays the opponent's move. Lichess stores the position before the opponent's last move, so I apply it to get the actual puzzle position.
Filters. White to move, rating 900–2000, well-liked and played often, at most 22 pieces so it reads well on a phone.
Verifies with my engine, and also checks that my engine's single key move matches Lichess's solution. Two independent sources agreeing is a good sign that both are right.

95 positions survived. I took every third one across the rating range, added two I'd composed myself, and shuffled them with a fixed seed so easy and hard days alternate.

What I like about this

The solver is a few dozen lines, and it replaces a checklist I would eventually have got wrong. When I add puzzles, the test either passes or tells me exactly which one is broken.

Update: weekends now get a mate in 3, verified by a generalised version of the same solver, and every past puzzle is in the archive.

If you haven't yet, go solve today's puzzle. Your streak lives in your browser, and the share button gives you a little 🟩 to brag with.

Originally published on simplecode.ca.