Technical consultancy & Ruby development

From fuzzy problem
to working software.

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 an open-source AI agent, end to end — no manual markup. It is not “AI sloppy”: 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.
• → Internal automation — AI-assisted workflows, Slack bots, and the tedious tasks that eat org time.

03 — Selected work

Engments in the field.

A selection of engagements, real clients.

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