coding-effectively

# Coding Effectively

## Required Sub-Skills

**ALWAYS REQUIRED:**

- `howto-functional-vs-imperative` - Separate pure logic from side effects
- `defense-in-depth` - Validate at every layer data passes through

**CONDITIONAL:** Use these sub-skills when applicable:

- `howto-develop-with-postgres` - PostgreSQL database code
- `writing-good-tests` - Writing or reviewing tests
- `property-based-testing` - Tests for serialization, validation, normalization, pure functions

## Property-Driven Design

When designing features, think about properties upfront. This surfaces design gaps early.

**Discovery questions:**

| Question                               | Property Type  | Example                        |
| -------------------------------------- | -------------- | ------------------------------ |
| Does it have an inverse operation?     | Roundtrip      | `decode(encode(x)) == x`       |
| Is applying it twice the same as once? | Idempotence    | `f(f(x)) == f(x)`              |
| What quantities are preserved?         | Invariants     | Length, sum, count unchanged   |
| Is order of arguments irrelevant?      | Commutativity  | `f(a, b) == f(b, a)`           |
| Can operations be regrouped?           | Associativity  | `f(f(a,b), c) == f(a, f(b,c))` |
| Is there a neutral element?            | Identity       | `f(x, 0) == x`                 |
| Is there a reference implementation?   | Oracle         | `new(x) == old(x)`             |
| Can output be easily verified?         | Easy to verify | `is_sorted(sort(x))`           |

**Common design questions these reveal:**

- "What about deleted/deactivated entities?"
- "Case-sensitive or not?"
- "Stable sort or not? Tie-breaking rules?"
- "Which algorithm? Configurable?"

Surface these during design, not during debugging.

## Core Engineering Principles

### Correctness Over Convenience

Model the full error space. No shortcuts.

- Handle all edge cases: race conditions, timing issues, partial failures
- Use the type syste