Technical consultancy & Ruby development

Engineering software
for professionals.

Consultancy — the applied craft of turning ambiguous problems into clear, maintainable software, as in code review and architecture; relentlessly pursuing accurate and truthful estimates.

We anchor our ethos, judgment, and our efforts in the fundamentals of software engineering. We take on a limited number of engagements at a time, work inside your team, and leave code that is easier to read than the day before.

Start an inquiry → See selected work →

This entire site was generated by a single AI agent, end to end — no manual markup. It is not “AI slow”: the harness matters more than the model. A tight loop, a clear brief, and a model with enough context to hold the whole page at once beat a larger, slower one every time.

01 — Design philosophy

Emergent over prescribed aesthetics.

These are not trends. They are the operating rules we apply to every engagement, dense on purpose, because clarity rarely fits in a single line.

Explicit over implicit.

Show the work; hide nothing that costs money to understand.

Expose state and inner workings.

A system you can read is a system you can fix.

Dense, not sparse.

Respect the reader's attention and the network's bytes.

Engineered for human vision.

Typography, rhythm, and hierarchy do the heavy lifting.

Regiment functionalism.

Every element must earn its place with a job to do.

Performance is design.

Fast is a feature, not an afterthought.

Verbosity over opacity.

Preferring a few extra bytes to a confused engineer.

Ignore design trends.

Timeless and unfashionable. We expect this to outlive yours.

Flat, not hierarchical.

Importance is earned by content, not by being big.

As complex as it needs to be.

Diametrically opposite of minimalism.

Objective reasoning.

Driven by common sense, metrics, and evidence.

Don't infantilize users.

Treat engineers and power users like adults.

Coffee first.

A well-brewed decision beats a fast one.

02 — Services

What we build and tend.

• → Technical consultancy — audits, roadmaps, and hands-on guidance where a team is stuck.
• → Ruby & Rails development — greenfield apps and steady-state services, idiomatic and tested.
• → Hotwire development — Turbo + Stimulus, server-driven pages without a JavaScript framework.
• → AI-driven SaaS — LangChain.rb, vector search, and backend-heavy AI integrations.
• → Architecture & code review — structural reviews that protect the next hire's sanity.
• → Legacy modernization — upgrading frameworks and debt without rewriting history.
• → Data & automation — analytics, pipelines, workers, and jobs that fail loudly and recover quietly.
• → Performance engineering — measuring, then making it fast.

03 — Selected work

Engments in the field.

A selection of engagements. Names withheld at client request.

04 — Inner workings

We expose the source.

A sample of the craft: small, explicit, and easy to read. This is the kind of code we leave behind.

# kava-ir-kodas — we brew software, one commit at a time
module Kava
  class Consultancy
    def self.brew(clients)
      clients.map { |client| client.with(self) }
    end

    attr_reader :client, :reviewed, :shipped

    def initialize(client)
      @client    = client
      @reviewed  = false
      @shipped   = false
    end

    def with(consultancy)
      consultancy.review!(self)
      consultancy.ship!(self)
      self
    end

    def review!
      raise Unreviewed unless reviewed
      self
    end

    def ship!
      raise Unreviewed unless reviewed
      @shipped = true
      self
    end
  end
end