IMMEDIATE CODE REVIEW for coding agents

and make invalid states unrepresentable™

Catch questionable decisions while your coding agent is still working. Hapsland reviews changed types and functions against your rules and catches mistakes before they waste tokens and time. Stop context poisoning before it starts

Download Hapsland ↗Set up with your agent ↓

Or install with Homebrew

brew install dearlordylord/tap/hapsland

MEANINGLESS COMBINATIONS

Can the model combine choices that do not belong together?

The issue

type Delivery = {
  method: "courier" | "pickup";
  destination: "home" | "pickup-point";
};

const delivery: Delivery = {
  method: "pickup",
  destination: "home"
};

This compiles. A pickup needs a pickup point, not a home address.

Design direction

type Delivery =
  | { method: "courier";
      destination: "home" }
  | { method: "pickup";
      destination: "pickup-point" };

Tie each delivery method to its destination. TypeScript can then reject the wrong combination.

DOMAIN VALUES

Can values with different domain meanings be used interchangeably?

The issue

function checkoutDiscount(price: number) {
  return price * 0.1;
}

const originalPrice = 100;
const amountAlreadyPaid = 40;
const discount = checkoutDiscount(
  amountAlreadyPaid
);

The discount is 10% of the original price. This returns 4 instead of 10.

Design direction

const discount = checkoutDiscount(originalPrice);

Calculate the discount from the original price, not the amount already paid. This returns 10.

PARTS OF ONE FACT

Can an edit separate values that only make sense together?

The issue

const cart = {
  productIds: ["tea", "coffee"],
  quantities: [1, 2]
};

cart.productIds.splice(0, 1);

Tea is removed, but its quantity stays. Coffee is now paired with 1 instead of 2.

Design direction

const cart = {
  items: [
    { productId: "tea", quantity: 1 },
    { productId: "coffee", quantity: 2 }
  ]
};

cart.items.splice(0, 1);

Keep each product and its quantity in one item. Removing the item removes both.

CONSISTENT NORMALIZATION

Do both sides of a comparison use the same representation?

The issue

function skuKey(sku: string) {
  return sku.trim().toUpperCase();
}

function sameSku(stored: string, query: string) {
  return skuKey(stored) === query;
}

sameSku("TEA", " tea ");

SKUs ignore case and surrounding spaces. This returns false for the same SKU.

Design direction

function sameSku(stored: string, query: string) {
  return skuKey(stored) === skuKey(query);
}

Normalize both values before comparing them. The same call now returns true.

Read this stage

Agent editDIFF

   title: string;
+  coverWidth: number;
   public: boolean;

GalleryCHANGED TYPE

interface Gallery {
  cover: ImageFile;
  title: string;
  coverWidth: number;
  public: boolean;
}

cover

ImageFileRELATED TYPE

interface ImageFile {
  path: string;
  dimensions: Dimensions;
  format: "jpeg" | "png";
}

dimensions

DimensionsRELATED TYPE

interface Dimensions {
  width: number;
  height: number;
  unit: "px";
}

GalleryEXCERPT

interface Gallery {
  cover: ImageFile;
  coverWidth: number;
  // other fields omitted
}

cover

ImageFileEXCERPT

interface ImageFile {
  dimensions: Dimensions;
  // other fields omitted
}

dimensions

DimensionsEXCERPT

interface Dimensions {
  width: number;
  // other fields omitted
}

REVIEW QUESTION

Can this type store two copies of the same fact that disagree?

GalleryEXAMPLE EDIT

interface Gallery {
  cover: ImageFile;
  title: string;
  public: boolean;
}

Read the width from cover.dimensions.width instead of maintaining two copies.

This edit is shown for illustration. The agent chooses how to respond to feedback.

GalleryRECHECK

interface Gallery {
  cover: ImageFile;
  title: string;
  public: boolean;
}

ImageFileRELATED TYPE

interface ImageFile {
  path: string;
  dimensions: Dimensions;
  format: "jpeg" | "png";
}

DimensionsRELATED TYPE

interface Dimensions {
  width: number;
  height: number;
  unit: "px";
}

The agent adds a field for the cover image’s width. The diff shows the new line and the lines around it.

FROM EDIT TO FEEDBACK

Review the decision before more code depends on it.

Your agent makes an edit
Hapsland selects eligible changed declarations using your file settings.
Your rules get code context
Related definitions enrich the diff. Jev classifies the supplied code against your questions.
Your agent gets feedback
Hapsland prepares a message from the result and your settings, so the agent can reconsider its approach.

FILE SETTINGS

Choose which files can enter the review.

Sending source to another service is a data-sharing decision. Retention after submission depends on the review service’s policy. Set includes, exclusions and privacy exclusions to choose which files can be used. Supporting files pass the same checks before reading; a project’s include cannot restore your exclusion.

{
  "version": 1,
  "includes": ["src/**"],
  "privacyExcludes": ["src/private/**"]
}

Selected definitions contain source code. With credentials and no file settings, all otherwise eligible files are selected. The current recipient is Jev; there is no per-request approval prompt. The integration is designed for other classifiers too.

Explore file settings ↗

RULES

Built-in questions. Room for your own.

Hapsland’s default rules ask about data and code design. Type rules examine what values a type permits. The built-in function rule asks whether a body uses structure its declaration does not reveal.

Can this type store the same fact twice, with copies that disagree?

Jev classifies code against the questions; Hapsland uses the result and your settings to choose the feedback message. Add local rules for your team's concerns. Choose their scope, thresholds and feedback messages. Rules run only when the supplied code meets their evidence needs. No feedback does not mean every check passed: a check may be skipped or fail to run.

See custom rules ↗

SETUP

Install and set up Hapsland.

Ready-made packages for macOS arm64 and Linux arm64. Runtime included; no source build required.

1. Install Hapsland

Download a ready-made package ↗

macOS arm64 · Linux arm64 · Archives and checksums

2. Set up your agent

Copy this instruction into your agent’s conversation. Setup previews hook changes and asks before applying them.

Install Hapsland for my coding agent using https://github.com/dearlordylord/hapsland/blob/master/docs/installation-workflows.md. Let me review and approve the setup changes interactively. Ask me to enter any Jev key in the masked setup prompt, not in chat.

Run setup manually after installing

Run setup in your Git repository

hapsland setup

Homebrew installs the runtime and commands. Setup previews changes to your agent hooks before applying them.

Choose Claude Code, Codex CLI, or both. Setup previews the hooks, asks before applying them, and requests your Jev key if needed. Restart the selected client and complete its trust prompts.

The integration applies to your client profile. File settings determine which repositories and files can be reviewed. Setup itself sends no review request.

Installation details and development builds ↗

3. Check a new edit

Restart the selected agent and complete its trust prompts. To inspect a review, enable local recording, make a new supported edit, then run:

hapsland dashboard

Recording is opt-in and contains source code and review messages. It does not backfill earlier edits. Opening the dashboard does not enable it.

Enable recording and inspect a review ↗

IMMEDIATE CODE REVIEW for coding agents

Review the decision before more code depends on it.

Your agent makes an edit

Your rules get code context

Your agent gets feedback

Choose which files can enter the review.

Built-in questions. Room for your own.

Install and set up Hapsland.

1. Install Hapsland

2. Set up your agent

Run setup in your Git repository

3. Check a new edit