Book → capstone → solution → repository

Solutions

Start with a real AI problem. Follow it through the mechanism, evidence, capstone implementation and inspectable code to a solution you can actually use.

Programmer.ie solutions are the practical destination of the research, books and experiments.

A book should not end at explanation. Each finished book is expected to lead to a solution: a durable page organised around a real problem, a concrete outcome and an implementation that can be inspected. The book earns the mechanism, the capstone integrates it, and the solution becomes the applied home for the work.

The publishing loop

    flowchart LR
    R[Research] --> B[Book]
    B --> C[Capstone]
    C --> S[Solution]
    S --> G[Repository]
    G --> U[Real use]
    U --> E[New evidence]
    E --> R

A solution can also begin somewhere else. A strong blog post, experiment or engineering investigation can grow into a solution when it becomes comprehensive enough to answer the problem rather than merely discuss it. The solution page then becomes the canonical home, while supporting posts provide narrower entry points into it.

How to use this page

Start with the problem Browse the solutions below by domain or featured project.
Understand the mechanism Each solution connects back to the book, experiment, or underlying technical argument.
Inspect the implementation A real solution leads to code, experiments, tools, or a live system.

What a solution is

A solution on Programmer.ie is not just an article and not just a repository.

It is the place where:

a real problem is named clearly,
the mechanism is explained properly,
the capstone implementation is gathered,
the code or live system is linked,
and the result can be inspected, tested or used.

Every mature solution should make five things easy to find:

The problem — what is failing, missing or unnecessarily difficult?
The mechanism — what technical idea actually determines the outcome?
The evidence — what measurements, experiments or source material justify the design?
The implementation — what capstone, repository or repository path embodies the answer?
The operating boundary — what the solution does, does not do and how you can tell whether it is working.

Some solutions below are live systems. Some are being built directly from current books. Others will appear as the library grows. The goal is not to manufacture a product for every chapter. It is to make sure important technical work eventually terminates in something concrete that can be built, tested, inspected or used.

01Book

Understand the current technique, mechanism, evidence and failure modes.

02Capstone

Turn the argument into a complete implementation that can be tested.

03Solution

Package the result around a real problem and a concrete outcome.

04Repository

Keep the implementation, experiments and evidence inspectable.

22Total solutions

5Live

1Building

16Reference

0Planned

Featured systems

Featured solutions

Each page keeps the problem, underlying mechanism, implementation and source material connected.

Live Plugin

OpenCode Remembering

A standalone memory runtime for AI agents that separates retrieval, historical recall, temporal validity, current work, trust, decisive selection, traceability, unfinished work, and explicit memory writes from permission to influence present behaviour.

Problem Long-running AI agents accumulate files, conversations, decisions, failures, instructions and changing project state, but ordinary retrieval cannot tell historical evidence from current guidance, relevant material from authoritative material, or remembered information from permission to act on it.

Outcome A standalone remembering runtime where canonical project history is retrieved strongly, routed by purpose, interpreted temporally, conditioned on the work being done, gated by standing, reduced to decisive provenance-bearing evidence, recorded in an immutable trace, with unfinished work tracked and explicit memory actions accepted without granting the writer authority over behaviour.

Book: Memory From First Principles Capstone: The Memory From First Principles application: a real coding-agent plugin implementing the book’s earned path from canonical project history through retrieval, routing, temporal state, safe framing, trust, decisive selection, durable traces, open loops, and explicit memory actions.