Abdullah Mohammed abodacs

name	loose-ends
description	Use when Ben asks what is left in a workstream, to tie up loose ends, or to triage open issues against work that just shipped.

Loose ends

A workstream rarely ends cleanly. Follow-ups get deferred in PR descriptions, issues it fixed stay open because nobody wrote Closes #N, task lists go unticked, and half-related issues drift out of date. This skill finds every loose end, ties off the ones the evidence settles, and hands the

Act as my backend engineering interview mentor for top-tier software engineering internships. I am preparing for interviews where I need to demonstrate not just knowledge of backend technologies, but the ability to reason about systems, understand what happens underneath abstractions, identify bottlenecks, debug failures, and make engineering trade-offs. Every day, give me exactly ONE backend engineering interview problem.

Daily Rotation

Strictly rotate between these categories:

Day A — Core Engineering / Internals

Give me a deep conceptual problem involving one or more of:

Databases

B-trees and indexes
Database pages and storage layout

Architecture Decision Records

Repository history and durable technical decisions are recorded in docs/adr/.

Before completing any non-trivial implementation thread or merge request, use the repository's record-architecture-decisions skill to evaluate whether the work produced a durable architectural decision.

When a decision is ADR-worthy, add a small record under docs/adr/ in the same merge request. Capture the constraints and evidence available at the time, including failed or rejected approaches that explain why the practical solution differed from the ideal one. If no ADR is needed, say so explicitly in the final handoff.

description	Implement with clear orchestration, strong interfaces, and happy-path-first design

Code like Luke.

Implement the requested change, but optimize the design for the normal user flow. If the happy path is 95% of runtime behavior, it should be approximately 95% of the code readers see.

Start with context:

inspect the existing code, callsites, data flow, and nearby conventions

name

govuk-style

description

Write and edit in GOV.UK / GDS house style — plain English, active voice, front-loaded content, sentence case, and no bold or italics for emphasis. Use when writing or editing reports, research write-ups, guidance, documentation, summaries, or any prose where clarity and accessibility matter.

user-invokable

true

args

name	description	required
target	The document or text to write or rewrite in GOV.UK style (optional)	false

LLM Wiki

A pattern for building personal knowledge bases using LLMs.

This is an idea file, it is designed to be copy pasted to your own LLM Agent (e.g. OpenAI Codex, Claude Code, OpenCode / Pi, or etc.). Its goal is to communicate the high level idea, but your agent will build out the specifics in collaboration with you.

The core idea

Most people's experience with LLMs and documents looks like RAG: you upload a collection of files, the LLM retrieves relevant chunks at query time, and generates an answer. This works, but the LLM is rediscovering knowledge from scratch on every question. There's no accumulation. Ask a subtle question that requires synthesizing five documents, and the LLM has to find and piece together the relevant fragments every time. Nothing is built up. NotebookLM, ChatGPT file uploads, and most RAG systems work this way.

name	go-tests
description	Generates Go unit tests using the Expectation pattern with cmp.Diff. Use when writing, adding, or fixing Go tests, or when working with _test.go files.

Go Tests

Table-driven tests using the Expectation pattern with cmp.Diff.

	# /// script
	# requires-python = ">=3.10"
	# dependencies = [
	# "pydantic-ai-slim[anthropic,typesafe,logfire]>=2.45.0",
	# ]
	# ///
	from typing import Literal

	import logfire
	from pydantic import BaseModel, Field

	import { signal, computed } from "@preact/signals-core";
	import { inject, useServiceState } from "./service";

	class WorldService {
	signal = signal("world");
	}

	class HelloWorldService {
	hello = inject(WorldService);
	signal = computed(() => `hello ${this.hello.signal.value}`);

	"""
	The most atomic way to train and run inference for a GPT in pure, dependency-free Python.
	This file is the complete algorithm.
	Everything else is just efficiency.

	@karpathy
	"""

	import os # os.path.exists
	import math # math.log, math.exp