How my teams work.
The operating system I wrote and rolled out across my teams — not slide-deck culture, but rules people actually reference.
Ten chapters: purpose, autonomy, trust credit, marathon quality, initiative, mistakes, responsibility, teamwork, legacy, and wellbeing. Adapted from internal docs; the tone stays direct because that is how we run.
Developer's purpose
Code is not the whole job — context, people, and business outcomes are.
Beautiful code matters, but it does not exist in a vacuum. Someone sets the task, someone accepts the result, someone tests it, someone uses it. A technically perfect solution can still miss the requirement or the real problem.
A developer's job is not only to write code, but to interact with everyone in the chain — analysts, designers, backend, QA, the lead — grow professionally, and understand the business context of the work.
The quality loop
Better code → faster application → more value for the business → more room to grow the team and rewards → better code again. This is not a poster on the wall. The quality of your work directly shapes what you work on tomorrow, what you learn, and what you earn.
We connect people
Our product is used by tens of thousands of people in critical industries — rail, oil & gas, education, government. We connect people. The quality of our work determines how well they can communicate and get their jobs done.
Autonomy
99% of cases should be solvable from docs — questions come with hypotheses.
We aim for team autonomy. For 99% of situations you should have either all artifacts you need — spec, design, API — or clear instructions on how to get what is missing.
Documentation is not decoration. It is detailed, structured, and kept current. Before you ask — spend ten minutes looking for the answer.
Questions that erode autonomy
Two patterns undermine the team: asking something that is already in the docs (often because you are afraid to own the answer — you probably already know it), and stating "I cannot solve this" without any attempt.
A good question sounds like: "I tried A, B, and C. A failed because X, B because Y. I think C is best because Z — am I right or is there a D?" The lead owns the final call. You bring attempts and hypotheses, not empty hands.
"Better to ask" ≠ "ask about everything"
We say it is better to ask than to build the wrong thing — but that means ask with preparation, not heroically drown alone for three days.
Fine to ask immediately when: departments contradict each other, requirements in spec or mocks are ambiguous (ask the owning function), or you need lead input on hidden nuance or unusual priority. Even then — show you understand the problem.
Trust credit
Everyone starts at maximum trust. It moves with your reliability.
Every engineer starts with maximum trust credit by default. That means: pick tasks in any order from the list (as long as you hit the deadline), the lead is not micromanaging every step, we trust your decisions within the task.
How credit drops
- Miss a deadline without warning — you let the team down
- Ask questions answered in the docs — you are not thinking first
- Ship work with many bugs — you are not checking your own output
- Repeat the same mistakes — you are not learning
Levels
- High: weekly minor list, any order, minimal check-ins, harder tasks
- Standard: sorted list, periodic status questions
- Low: closer control, simpler tasks — takes real effort to get here
Early on there may be slightly more oversight — normal. Once the lead sees you can fly, you get more room.
Maximum credit is not permanent — we watch everyone, and credit can drop. If it drops, it is not a verdict — we help you earn it back. Trust credit is live feedback on your current reliability.
Marathon
Quality over speed — hypothesis first, polish second.
We play the long game. Shipping slop gives a short boost and collapses later — that is lost money. Debating patterns for weeks instead of writing code is also lost money. Balance both, never forget the commercial goal.
Hypothesis → quality
We have hard bi-weekly minor deadlines. How to stay quality-minded?
- Write rough code fast — a hypothesis sketch
- Open an MR with high-level implementation (pseudocode is fine)
- Get feedback — is the hypothesis right? is the architecture sound?
- Then polish — refactor, optimize, tests
Hypothesis takes 30 minutes to two hours. Feedback takes one to two hours on review. After that you can develop calmly, knowing the direction is right.
Shortcuts vs missing the date
If the choice is "ship on hacks" or "redo properly and miss the minor" — flag the lead early, show a plan with time estimates. The lead decides: hacks plus follow-up refactor, or move the task. Silent heroics are not responsibility.
Initiative, not heroics
Find problems, estimate impact, align — do not suffer in silence.
Heroics are bad
Heroics: stay quiet, miss deadlines, work nights, ship on three floors of hacks — or ship nothing. It burns you and lets the team down.
Initiative is good
Initiative: you found a problem, sized impact on your timeline, aligned with the lead, then fixed it if there is time.
Example: you find a bug in someone else's code while on your task — note it in the MR (what, where fixed, likely origin), ask QA to watch that area. Unrelated bug → separate ticket.
Initiative = found + estimated + aligned + fixed (if time). Heroics = found + fixed alone + blew your dates.
From the hypothesis workflow: sketch your code, highlight problems in others' code in the same MR. If approved, you may fix both — the lead decides if we have time for one or two.
Mistakes
Errors are normal. Hiding them is not.
Mistakes are part of the job. Nobody expects perfection on day one — or ever. What matters: speak up immediately, learn why it happened, do not repeat the same failure.
Worst case
- Hit a problem
- Stay quiet and try alone
- Deadline approaches
- Last day: "I will not make it"
Better case
- Hit a problem
- Try to solve it (hypotheses collected)
- After a few hours or half a day — ask
- Solve together or escalate
Once is fine. Twice in the same place is a question. The same bug pattern across your tasks — build a pre-QA checklist, study the gap, ask a senior.
Responsibility
Use "I", not "it happened". Criticism of work is not criticism of you.
You own the outcome of your work. Missed a deadline — your actions led there. Shipped a bug — you did not verify. Unclear requirements — you did not ask.
Stop passive voice
Wrong: "The task did not get done", "The MR did not merge", "Time ran out", "Nobody told me".
Right: "I mis-estimated", "I missed the edge case", "I did not check the artifacts before starting".
We all err — that is fine. Take responsibility without panic: we optimize for fixing, not punishment. Saying "I got it wrong" is maturity, not weakness.
On feedback
Feedback on code is not an attack on you as a person. Do not deflect, sulk, or nod without changing. Clarify the issue, ask how to do better next time, fix it, update your checklist or study plan. The person does not become worse from code review — the work gets better, and that is the point.
Teamwork
Sometimes solo, sometimes together — code review is non-negotiable.
Sometimes the mode is solo execution — sit, build, ship. Sometimes it is collaborative — brainstorm, pair, dissect a hard task. The lead sets the mode. Be ready for both.
Code review is a duty
Review is not "when I have time". It is a core obligation of every developer.
- You learn from others' code
- The team converges on style and approach
- Bugs are caught before QA
- Knowledge spreads across the system
Review thoughtfully: not a drive-by approve — real analysis, comments that teach, questions when unclear. Ideally, pull the branch locally.
Legacy & tech debt
Old code is normal — refactor with a plan, not in secret.
Legacy happens. Products evolve, requirements shift, stacks age. We refactor — but not silently.
- Show a plan — what, why, system impact
- Align with the lead — time now? risk to critical paths?
- Ship in small iterations, not a stealth half-project rewrite
Tech debt
Same pattern: log it (ticket or comment), rate severity — time bomb or livable? agree a fix plan with the lead. Do not hoard debt quietly; do not freeze all feature work to chase debt only.
Wellbeing
You are not a machine — speak up before you break.
Developers are human. Fatigue, anxiety, life outside work — normal. If something is off, say so.
- Tired — say it. Maybe a day off or task reshuffle
- Anxiety or burnout — say it. Better now than after the crash
- Life problems eating your head — say it. Loss, illness, money stress — it affects work
A few days to recover or sort life is cheaper than losing someone permanently. Burnout and silence lead to mistakes, conflict, and attrition.
Personal details are optional — "I need a few days" is enough. But silence is not — the lead cannot guess.
Want your teams to work this way?
I help engineering orgs build delivery systems people actually follow — not culture decks that collect dust.