Skip to content
KODE Product OS

Principles

Seven principles guide how we make decisions, especially the ones no process covers.

These principles apply to everyone in product and engineering, whatever their role or level. They put our culture into practice. Each one says what it looks like when it's working, and what to watch for.

  1. 1. Care deeply

    We care about our team's success and about the people who use our software. When something breaks in production we look at the system, not for someone to blame. Blameless does not mean unaccountable; we own the follow-through.

    You'll see it when
    People notice when a teammate is stuck or overloaded and step in. Incident reviews end with fixes, not names.
    Watch for
    Problems get handed off with no one following through, or someone is quietly singled out after an incident.
  2. 2. Stay curious

    We ask why, learn from customers and from each other, and try new tools, including AI, with an open mind and a critical eye.

    You'll see it when
    People ask why before they build, share what they learned, and try new tools to see if they help.
    Watch for
    "That's how we've always done it" ends a discussion, or a tool is adopted or rejected without anyone checking.
  3. 3. Collaborate without ego

    The best idea wins, wherever it comes from. Every change gets a review, at every level, because review spreads learning and alternative approaches.

    You'll see it when
    Reviews include real questions and alternatives, and people change course when a better idea comes up.
    Watch for
    Reviews become rubber stamps, someone treats feedback as an attack, or a decision gets reopened after the team agreed.
  4. 4. Be pragmatic

    We choose the simplest approach that solves the real problem, and we ship useful increments rather than waiting for perfect.

    You'll see it when
    Solutions are as simple as the problem allows, and trade-offs are written down where others can see them.
    Watch for
    Work stalls waiting for the perfect design, or complexity is added for problems we don't have.
  5. 5. Deliver value quickly

    We take the shortest path from idea to customer value. Small batches, frequent deploys and feature flags let us release as soon as the business is ready.

    You'll see it when
    Small changes ship often, and customers see useful increments well before a project ends.
    Watch for
    Large changes wait weeks to merge, or a project ships nothing until everything is done.
  6. 6. Own quality

    Our engineers are our QA team. Every engineer owns the quality of their own changes and of the whole team's work.

    You'll see it when
    Engineers test their own work, check it in production after release, and catch problems before customers do.
    Watch for
    People rely on someone else to find their bugs, or releases go out without anyone checking them.
  7. 7. Leave it better

    Code, documentation and processes should be a little better after we touch them. Cleanup is part of the work, not extra credit.

    You'll see it when
    Cleanup happens alongside the work, and the post-live milestone gets done.
    Watch for
    Old flags and workarounds pile up, and each project inherits more mess than the last.