Sentinel AI Agent

Introduction

As our systems grew, so did the burden of maintaining them. What began as efficient and elegant code became increasingly difficult to reason about, review or extend. It wasn’t one specific technology that failed us — it was the absence of structure across the board.

We encountered components whose logic was correct but whose intent was buried in noise. Files looked different, not because they solved different problems, but because they were written on different days by different minds under different assumptions. Reviews focused on what was happening rather than why and we were continually resolving;

  • style inconsistencies;

  • shifting patterns;

  • fragile architecture;

  • invisible responsibilities; etc.

We weren’t looking for another library, linter or framework.

We were looking for a system of discipline — a way to codify structure, declare contract and reclaim clarity across all layers of the codebase including but not limited to;

  • styling;

  • logic;

  • configuration

  • naming; and,

  • team practice; etc.

Sentinel is that System

It is not just about styling — though styling is where the lack of structure is often felt first. Sentinel provides a unified declarative model for;

  • component structure;

  • separation of concerns;

  • naming conventions, intent clarity and reusability;

  • canonical ordering and formatting rules;

  • styling discipline via tokens, grouping and named style objects (NSO)

  • controlled customization without chaos.

Reviewability, traceability and long-term stability

Sentinel doesn’t slow teams down. It removes ambiguity. It front-loads decisions that would otherwise bleed into dozens of micro-choices. It replaces best guesses with shared rules. It removes the “I think it’s fine” from reviews and replaces it with “it complies or it doesn’t.”

It’s a framework for how we work — not just what we write.

Sentinel Overview

Sentinel is a structured design system for code — not just styling. It brings clarity and consistency across how we write, structure and reason about everything from page layouts to environment configs. It defines conventions for structure, formatting, naming, file responsibility and design token use. Sentinel is not a plugin or a tool — it is a set of rules that create shared certainty.

Where frameworks focus on features, Sentinel focuses on discipline. It offers answers to questions like;

  • where does this go?

  • what should this be called?

  • what controls this?

  • what breaks if I change it?

Sentinel applies at every layer of the stack. From layout scaffolding to tokenised theming, from naming strategies to source order rules, it ensures that decisions are intentional, repeatable and reviewable.

It doesn’t enforce uniformity for its own sake — it enforces clarity so that decisions never get buried beneath guesswork. Its goal is to make code navigable, reviewable and safe to evolve.

Scope and Application

Sentinel governs;

  • component structure — how we separate concerns and assign responsibility;

  • naming — ensuring that semantics and scope are always visible;

  • token design — consistent use of @theme variables, scoped overrides and token fallbacks;

  • ordering and grouping — from properties in style blocks to import statements in files;

  • file and folder conventions — separating by concern, not by type;

  • review clarity — every file should say what it is, why it exists and how it relates to others.

Within this system, we also define structured units like Named Style Objects (NSOs), which provide reusable, semantically-scoped styling patterns. These are discussed later, after the foundation is laid.

Why Sentinel Matters

Modern projects don’t fail from lack of tooling — they fail from slow erosion of clarity. Sentinel is designed to prevent that erosion. It gives your project a spine — a set of rules that everyone can align to, regardless of experience, seniority or personal habits.

  • By front-loading structure, we eliminate confusion.

  • By enforcing naming and grouping, we reduce review friction.

  • By applying discipline early, we create freedom later.

Sentinel isn’t about styling. It’s about trusting your codebase again.