Juber Shaikh’s Open-Source AI Tools: A Practical Guide to Forgekit, Hikmah Stack, and Wisdom Lens

Disclosure: This post showcases open-source tools created by the author (Juber Shaikh), including forgekit, wisdom-lens, and hikmah-stack.

An AI coding assistant can write a useful patch and still leave you with a difficult review. Which earlier decisions did it remember? What else might the edit break? Does “finished” mean the tests passed, or simply that the conversation stopped?

These questions connect three public projects from Juber Shaikh, known on GitHub as CodeWithJuber: Forgekit, Hikmah Stack, and Wisdom Lens. Each approaches a different part of the problem, from everyday coding checks to structured agent memory and better working instructions.

The useful way to explore this portfolio is to start with the friction in your own workflow. A developer tired of repeating repository rules needs a different entry point from someone building a memory-backed agent application.

Disclosure: the projects featured here are Juber’s own public open-source work. This is a promotional overview, grounded in public source and documentation reviewed on October 3, 2026. The workflows below are illustrative examples, not claims of customer deployments or measured productivity gains.

A developer portfolio with a clear engineering focus

Juber’s public GitHub profile describes him as a senior full-stack and AI application engineer based in Dubai. It lists work around cloud-native systems, agent reliability tools, governed connectors, and durable agent memory. That is a self-description; the repositories provide the more concrete material to inspect.

Across these three projects, a recurring design choice is to keep useful information outside a transient conversation. Project rules can live in files. A memory can preserve its source. A completion claim can be checked against a test result. Instructions can ask the assistant to define scope before it expands a task.

That shared interest does not make the projects interchangeable. Forgekit supplies practical coding tools. Hikmah Stack includes a Rust runtime for structured state and bounded controls. Wisdom Lens supplies guidance that an existing AI host can load. Each can be evaluated separately.

Illustration: a source-derived map of project roles, not a bundled architecture or a claim that the three install together automatically.

Forgekit: make the coding session easier to inspect

Forgekit is the most direct starting point when your problem lives inside an existing code repository. Its Node.js CLI and MCP server support shared project knowledge, likely change-impact inspection, verification, and configuration for multiple coding assistants. The reviewed package is version 1.11.0 and requires Node 20 or later. Package manifest

Imagine changing an authentication helper that several routes use. Before editing, you want to recover the team’s earlier decision and find likely callers. After editing, you want a clear account of the checks that ran.

Forgekit exposes that sequence through commands such as forge ledger query, forge impact, and forge verify. Its memory records can carry evidence references. Its Atlas index estimates relationships in the code. Its verification result distinguishes PASS, FAIL, INCOMPLETE, and NOT_CONFIGURED, rather than treating every missing check as a success. Workflow overview, verification implementation

Those distinctions are useful during review: a teammate can ask which suite passed on which code state, instead of relying on the assistant’s summary alone.

There are limits. The impact graph is heuristic and can miss affected files. Claude Code has the deepest hook integration; other hosts do not receive identical automatic enforcement. Forgekit is described as beta and is not a security sandbox. Start with a small repository and inspect the generated configuration before adopting more automation. Integration matrix, security policy

For the detailed workflow and setup boundaries, read the Forgekit review.

Hikmah Stack: give agent memory a structure you can examine

Hikmah Stack is a different entry point. Its version 3.1.0 Rust library and CLI provide typed memory traces, a local ledger, structured conflict detection, recall, commitments, and bounded decision or planning mechanisms. Portable instruction skills sit alongside the runtime. Kernel library

Consider an agent investigating a deployment issue. An older runbook says the service uses one database port; a migration note names another. Flatten both documents into a summary and it becomes easy to lose the disagreement.

Hikmah can preserve each statement with its source and metadata. When the application supplies a shared structured claim key with different values, the conflict can be surfaced instead of silently choosing a winner. A correction can supersede an earlier trace while retaining history. Trace structure, claim handling

That gives an application developer building blocks for an inspectable memory workflow. The surrounding application still has responsibilities: choose what to store, supply accurate metadata, call the kernel, and present unresolved questions to a person.

The boundaries are specific. Recall is lexical and tag-based. Structured conflict checks are not general natural-language contradiction detection. A hash chain helps check record integrity but does not establish that a statement is true. Installing the skills alone does not connect every host conversation to the Rust kernel. Recall implementation, compatibility guide

The Hikmah Stack review walks through the local memory flow and its integration requirements.

Wisdom Lens: improve how a task is framed and reviewed

Wisdom Lens starts with instructions. Its four skills cover building discipline, AI failure diagnosis, decision structure, and broader working habits. The package also includes supporting references, an advisor definition, and prompt-based response checks. The reviewed manifests identify version 1.2.1. Repository overview

Suppose an assistant keeps expanding a simple dashboard fix. The useful intervention may be a better task boundary: preserve the existing API, change only the relevant screen, show the resulting artifact, and list what remains unverified.

The Builder Protocol skill encourages measurable specifications, verification, written handoffs, and visible uncertainty. New Lens supplies failure-diagnosis guidance. Decision Engine helps structure a choice and consider a reversible experiment. These are inspectable instructions that developers can read and adapt. Builder Protocol, Decision Engine

The package relies on the host’s existing model, tools, and permissions. Its prompt hooks ask a model to review a response; they do not prove factual correctness or provide a deterministic security boundary. Host support also varies, so read the compatibility notes before expecting the same behavior everywhere.

Wisdom Lens is a sensible place to start when the immediate problem is unclear scope or weak review habits. The Wisdom Lens review explains each skill and the distinction between package validation and actual judgment quality.

Which project should you explore first?

• Repeated repository context and unclear test evidence: start with Forgekit. Check retrieved facts, likely impact, and verification coverage.
• An application needs traceable memory and corrections: start with Hikmah Stack. Check trace provenance, conflicts, recall, and host integration.
• Tasks drift or decisions lack clear criteria: start with Wisdom Lens. Check scope, evidence requests, uncertainty, and inspectable output.

This is a practical selection guide, not a ranking. The projects overlap in their concern for evidence, but they operate at different levels. You do not need to adopt all three to learn something useful.

A realistic workflow: one change, three useful questions

Take a small maintenance task: change a token-validation rule without altering the public response format. The following is a proposed evaluation workflow, not an automatic integration between the repositories.

First, define success. A Wisdom Lens-style brief could specify the allowed behavior change, the boundary cases to test, and the files or interfaces that must remain stable. This makes later review less subjective.

Second, inspect the repository. With Forgekit configured for the chosen assistant, query relevant project knowledge, inspect the helper’s likely impact, make the edit, and run verification. Compare its suggestions against the code you actually review. Record a missed caller as a useful failure case.

Third, consider continuity if you are building your own agent application. Hikmah could store the reviewed decision and later correction as structured traces. That requires explicit application wiring. The application should preserve where the evidence came from rather than marking the assistant’s own assertion as verified.

At the end, ask concrete questions: did the brief prevent unwanted scope growth? Did impact inspection reveal a relevant dependency? Could another developer reconstruct what changed and what was checked? Those observations are more useful than counting generated lines.

What this portfolio demonstrates, and what still needs testing

The public artifacts make several engineering choices visible: configuration emitters and verification states in Forgekit, typed records and correction history in Hikmah, and reusable review guidance in Wisdom Lens. That is the strongest basis for exploring Juber’s work.

Test and validator results support the behaviors they exercise. They do not establish universal host compatibility, production readiness, a guaranteed reduction in hallucinations, or superior task performance. These projects are not presented here as AGI or as a replacement for accountable human review.

Before adoption, check configuration changes, permissions, and data destinations. Repository-local storage is not a blanket privacy guarantee. Optional provider features and the AI host itself can involve network processing. Start with non-sensitive examples, read the relevant security documentation, and keep a simple way to remove the integration.

Explore one project, bring back one useful observation

Choose the repository closest to your current problem and try one bounded task. Keep the version, inputs, expected result, and actual result together. A reproducible issue about a missed dependency, a confusing memory conflict, or unclear instructions gives maintainers something concrete to improve.

You can explore all three through CodeWithJuber’s GitHub profile. If a project helps your workflow, consider starring it, opening a thoughtful issue, or contributing a focused improvement. The source is there to examine; start with the part you can test.

Visual credits

The cover is an AI-generated editorial illustration, not a product screenshot. The comparison diagram is an original source-based explanation of three independent projects; it does not depict an automatic bundled integration.