Draft hiring plan. The nine roles, location, pay, perks and hiring steps need owner confirmation. Applications record interest in these drafts.

Our values

Six things we hold to.

They shape what we build, how we write and who we hire. Each one has a figure, and each one has practices you can check.

01

Show the receipt

A result without evidence is a guess.

We prove work with the check that ran, the output we read and the cost we paid. We keep what is planned, built, shipped and proven apart.

  • Every release is verified on the real thing, then logged.
  • We state what we did not test.
  • We never claim a saving without a matching run.

02

Keep the work

Nothing a person taught should be lost.

Memory, corrections and decisions stay with the organization. A change of model or vendor must not cost anyone their context.

  • Export and exit are features, not afterthoughts.
  • Providers are always replaceable.
  • We design for the second task, not only the first.

03

Plain words

Short sentences. Simple words. One idea at a time.

We write for people who are busy, and for models that follow instructions. Clear text is cheaper to read and cheaper to run.

  • Technical text follows our writing rules and a scoring test.
  • We cut the filler, then cut again.
  • We say “do not” when we mean “do not”.

04

Rails before reasoning

Let the model create. Let code enforce.

Budgets, permissions and gates are code. A prompt can ask for good behavior, but only a rule can guarantee it.

  • Acceptance checks are executable.
  • New decision points start in shadow mode.
  • No mode ever weakens a hard gate.

05

Small team, big leverage

Add a lever before you add a person.

We stay small on purpose. We build tools, workers and rails that let each person do far more, and we use our own product to do it.

  • One writer per file, one owner per area.
  • We automate a task the second time we do it.
  • We delete more than we add.

06

Ship, then verify

Release often. Look at what you released.

Small validated steps go to production at once. We then open the real page, read the real log and fix what we find. No blame. We learn.

  • A unit of work is not done until it is live and checked.
  • A failed gate rolls back, then we fix it.
  • Every failure leaves a short note so we do not repeat it.

Do these sound like you?

Then we should talk. Read the roles, and tell us which value you would hold us to.