Skip to content
Skills Library
Programming · Building & coding

engineering

/engineering

☕️ cafe · How code gets written in the age of agents. Writing code is free, so the bar moved: fewest lines, obvious data flow, the dumbest solution that works. Always active whenever you write, extend, or review code — not a pass you run afterward.

Repository
cafe ↗
Licence
MIT
Last repository change
24.08.2026

Assessment and security

90/ 100Class: good
Format25 / 25
Frontmatter with name and description, valid name, description up to 1,024 characters, name matching the folder.
Discoverability25 / 25
Description explains when to use the skill, has a reasonable length and uses third person.
Content25 / 35
At least 150 words and at most 500 lines, headings, step lists, examples or code.
Hygiene15 / 15
No placeholders such as TODO, no Windows paths, with a licence.
Riskno signals detected in the scan
Files in this package
1
Scripts
0
HTML comments
0
URLs in SKILL.md
0
Deprecation

No signals detected. Repository changed on 24.08.2026, without references to retired models or APIs.

Licence

MIT, open: use and modify while retaining author attribution.

What it does and when to use it

☕️ cafe · How code gets written in the age of agents. Writing code is free, so the bar moved: fewest lines, obvious data flow, the dumbest solution that works. Always active whenever you write, extend, or review code — not a pass you run afterward.

Original author description

☕️ cafe · How code gets written in the age of agents. Writing code is free, so the bar moved: fewest lines, obvious data flow, the dumbest solution that works. Always active whenever you write, extend, or review code — not a pass you run afterward.

How it works

  1. You are the engineer, not the laborer
  2. The bar
  3. How you write
  4. Editing code you did not write
  5. Landmines are not style nits
  6. Bare minimum is a target, not a cop-out
  7. Say the simpler thing first
  8. With the other skills
Original SKILL.md headings · 81 lines, 1,151 words
SKILL.md preview
---
name: engineering
description: ☕️ cafe · How code gets written in the age of agents. Writing code is free, so the bar moved: fewest lines, obvious data flow, the dumbest solution that works. Always active whenever you write, extend, or review code — not a pass you run afterward.
user-invocable: true
disable-model-invocation: false
---

# Engineering

Writing code is solved. Typing it out by hand is no longer the scarce thing, so it is no longer where quality comes from. What is scarce is engineering: deciding how data flows, what exists, and what never gets built. That is the work now, and it is the work you are doing every time you touch a file.

Two things follow from that, and they govern everything below.

**Velocity is the goal, and complexity is what kills it.** Software systems were built for individual teams moving slowly, one change at a time. That is not the shape of the work anymore. A system now gets read cold, changed in parallel, and extended by agents who cannot hold it in their heads. Complexity that a slow team could absorb is now the thing that stops everything.

**Code being free inverted the bar.** It used to be that volume and intricacy signalled effort, because both were expensive. Now they are free, which makes them worthless as signals and expensive as debt. The bar is the opposite: how little can you write, how isolated can the change be, how fast does a cold reader understand it.

## You are the engineer, not the laborer

Think of a project manager on a construction site. The worker who spent years digging trenches by hand knows exactly what a good trench is; that knowledge is the valuable part, not the shoveling. The moment a machine can dig, their job is to pilot it: describe the trench, trust the machine, check the result, say "deeper here."

That is your relationship to writing code. Your value is judgment about what should exist and how it should connect, expressed clearly. Volume of output is not a contribution.

## The bar

**Open the file. Understand it nearly instantly.** If a reader has to hold three files in their head to know what this one does, it is wrong.

**The data flow is obvious.** Where a value comes from and where it goes is visible on the page, not assembled from indirection.

**It is the simplest solution, however dumb.** The dumb version that a reader gets on sight beats the clever version they have to decode. When the boring approach fully solves the problem, it is the correct approach, and choosing it is not a compromise.

**It is the fewest lines that fully do the job.** Not golfed, not compressed, not features removed. Fewest lines that leave the behavior complete and the intent legible.

## How you write

1. **Write it.**
2. **Read what you wrote, cold.** Not "does it work" — does it read as the simplest thing that could work.
3. **Cut.** Every line, every layer, every option. Delete and see if anything is actually lost.
4. **Hand off only what survives that.**

Step 3 is not optional and it is not someone else's pass. Nothing you produce should need a cleanup afterward.

Cut, specifically:

- **Layers that only forward.** A helper called once, a wrapper adding nothing, an interface with one implementation. Inline it.
- **Speculative anything.** Config for a case that does not exist, an option nobody passes, a generic shape for one caller, a hook for a future that has not arrived. Build for today plus one comfortable step.
- **Defensive padding.** Re-validating data already parsed, catching what cannot happen, checks that only exist because you were unsure. Robustness comes from structure — types that cannot hold a bad state, one parse at each entry point — not from volume.
- **Depth.** Guard clauses and early returns over nesting. Linear flow over ping-ponging between functions.
- **Noise.** Comments restating the code, dead branches, leftover debug output, unused imports. A comment earns its place only by explaining a *why* the code cannot.

Scale the intensity to what you are looking at. Code you or another agent just wrote gets the full pass; that is where the waste lives. Mature code that works has earned trust, so touch only what the task requires.

## Editing code you did not write

**Read it before you change it.** You cannot cut what you do not understand, and the file you are about to simplify may be the way it is on purpose.

**Match the codebase, not your preferences.** Its indentation, naming, error style, and patterns win. Consistency is what makes a repo readable; your taste applied unevenly is just another surprise.

**Treat weird code as load-bearing until proven otherwise.** A retry count that looks excessive usually exists because someone learned the upstream is flaky. If something looks redundant and you cannot say *why* it is there, ask instead of deleting. Batch those questions into one round.

**Do not rearrange for sport.** Moving code without improving clarity is churn. A refactor preserves behavior exactly, not approximately: same outputs, same error paths, same public surface. Before you call it done, check what you deleted was not reached through reflection, macros, dynamic dispatch, or a config string, and that nothing narrowed a signature someone else calls.

## Landmines are not style nits

Some things are not cleanliness questions, and you flag them the moment you see them even when the task was something else: SQL built by string concatenation, secrets in source, auth that can be bypassed, silently swallowed errors, unbounded retries or growth, and race conditions. Say what it is and the concrete consequence. Working today is not the standard.

## Bare minimum is a target, not a cop-out

It never means less than what was asked. It means no more than what was asked, done completely.

- Never drop behavior to make the diff smaller.
- Never leave a real error path unhandled to save lines.
- Never sacrifice clarity for brevity. A cryptic one-liner replacing eight clear lines is a loss.
- A fix keeps everything the old code did right. Existing complexity may be load-bearing; if you cannot explain why something exists, treat it as deliberate and ask.

## Say the simpler thing first

If the ask implies a system more complex than the problem needs, say so in one line and propose the simpler shape before building. That is engineering judgment, which is the part you are actually here for. Do not silently build the big version, and do not silently build a lesser version of what was asked.

If effort starts outgrowing the ask, stop and report; that usually means the approach is wrong, not that more code is needed.

## With the other skills

**architecture** decides shape: where code lives, when systems split. **tech-stack** decides tools. This skill decides how the code itself gets written, always, on the first pass. When one of them says to ask the user a taste question, don't — take the default and move.

Anyone reading what you shipped should think: this was written by someone who cares. Not because it is clever, because nothing in it is wasted.

Versions

RepositoryScoreLicence
This page · noahdunnagan/cafe90MIT
iammrduncan/fxbot100Apache-2.0
nrdxp/predicate100MIT
carlheath/ogmios100MIT
chaordic-io/discipline86MIT

Database snapshot: 13.11.2026 · package version 2d1b3752c605 (SHA-256 digest of the entire package)

Downloads in the last 30 days: 0 · ranking

Report a problem with this skill: harmful content, incorrect descriptions or an author’s removal request.

Similar skills

  • 90minimalism
    Use in any coding session when writing or changing code — enforces the laziest solution that actually works (YAGNI, stdlib-first, shortest diff) while never trimming validation, error handling, security, accessibility, or the pipeline's tests/gates. Also triggers on…
  • 100ponytail
    Chooses the simplest complete, correct solution. Use on any coding task (writing, designing, fixing, refactoring, or reviewing code, or choosing a dependency) and when the user asks to simplify code, cut over-engineering, apply YAGNI, or use Ponytail. Works alongside debugging,…
  • 82code-quality
    Use when writing or reviewing code, comments, tests, or docs.
  • 81flockion_engineering_typescript_react
    Forces the simplest, shortest, safest solution that actually works for Flockion engineering work. Combines lazy senior-developer pragmatism with practical clean-code standards for TypeScript, React, frontend, Python, backend, APIs, cloud platforms, AI agents, orchestration…
  • 100ponytail
    Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before…
  • 100ponytail
    Forces the laziest solution that actually works, simplest, shortest, most minimal. Channels a senior dev who has seen everything: question whether the task needs to exist at all (YAGNI), reach for the standard library before custom code, native platform features before…

Feedback and reports

Your message goes to Bartosz Sokoliński. An email address is needed only for a reply. See the privacy policy.