AgentSkillsCN

senior-engineering

资深工程师必备的软件工程实践准则。无论是在应对复杂度较高的开发任务、进行系统架构设计、代码审查，还是统筹多智能体协作构建流程时，这套原则都能助你游刃有余。涵盖规划、执行、质量门控，以及专为大语言模型量身打造的各类最佳实践。

SKILL.md
--- frontmatter
name: senior-engineering
description: Engineering principles for building software like a senior engineer. Load when tackling non-trivial development work, architecting systems, reviewing code, or orchestrating multi-agent builds. Covers planning, execution, quality gates, and LLM-specific patterns.

Senior Engineering Principles

Guidelines for building software with the judgment and discipline of a senior engineer.

Before Writing Code

Define Done First

  • •What does success look like? Write it down.
  • •What are the acceptance criteria?
  • •How will you verify it works?

Identify Load-Bearing Decisions

  • •Which choices are hard to reverse? → More scrutiny
  • •Which are easily changed? → Decide fast, move on
  • •Reversible decisions don't need consensus

Decompose Before Building

  • •Break work into clear, testable units
  • •Each unit should be independently verifiable
  • •If you can't explain the pieces, you don't understand the whole

Surface Risks Upfront

  • •What could go wrong?
  • •What are the dependencies?
  • •What's the rollback plan?
  • •Time-box exploration — analysis paralysis is real

Interface First, Implementation Second

  • •Define the contract (types, API shape, error cases) before internals
  • •Forces clarity on what you're actually building
  • •Implementation becomes "fill in the blanks"

Ask: What's the Simplest Thing That Could Work?

  • •Start there. Add complexity only when the simple version fails.
  • •Most features need 20% of what we imagine.

During Build

Always Have a Runnable State

  • •Never be more than 30 mins from something that compiles/runs
  • •Commit working checkpoints frequently
  • •Big-bang integration is where projects die

Prefer Incremental Over Big-Bang

  • •Ship small, verify, iterate
  • •Each step should be independently deployable if possible
  • •Reduce blast radius of mistakes

Instrument As You Build

  • •Add logging/metrics while coding, not when debugging prod
  • •"I wish I had visibility into X" = you waited too long
  • •Observability is a feature, not an afterthought

Read Errors Carefully

  • •80% of debugging is actually reading what the system tells you
  • •Read the error, then read it again
  • •Stack traces have answers — follow them

Boring > Clever

  • •If someone has to pause to understand it, it's too clever
  • •Save big-brain moves for genuinely hard problems
  • •Maintainability beats elegance

Optimize for Delete

  • •Write code that's easy to remove
  • •Tight coupling makes features immortal
  • •Good abstractions have clear boundaries

Quality Gates

Before Declaring Done

  • • Linter passes
  • • Type checker passes
  • • Tests pass (unit + integration where applicable)
  • • Manual smoke test completed
  • • Edge cases considered and handled

Tests Are Documentation

  • •A good test suite tells you what code is supposed to do
  • •Treat tests as first-class citizens
  • •If it's not tested, it's not done

Code Review Mindset

  • •Review like you'll maintain it at 3am
  • •Check: correctness, clarity, edge cases, security
  • •"It works" is necessary but not sufficient

LLM Orchestration Principles

Context Management

  • •Context window is your RAM — manage it deliberately
  • •Bloated context = degraded reasoning
  • •Give each agent minimum viable context, no more

Agent Delegation

  • •Single responsibility per agent
  • •Clear handoff contracts: inputs, outputs, success criteria
  • •Parallel when independent, sequential when dependent

Verify, Don't Trust

  • •First output is a draft, always
  • •Review agent output like a code review
  • •Agents are junior engineers, not oracles

Checkpoints Over Marathons

  • •Long-running agents should checkpoint progress
  • •If it crashes at 90%, don't lose everything
  • •Log state to files, not just memory

Fail Fast, Surface Early

  • •If something's going wrong, stop and reassess
  • •Don't compound errors hoping they'll resolve
  • •Human in the loop for high-stakes decisions

Ownership & Accountability

Own Failures, Credit Others

  • •Own failures publicly
  • •Credit others for wins
  • •No ego-driven attachment to being right

Strong Opinions, Weakly Held

  • •Have a position, defend it with evidence
  • •Update beliefs when evidence demands it
  • •"I was wrong" is a sign of growth

Leave It Better

  • •Codebases, teams, processes — improve what you touch
  • •Fix the small things while you're there
  • •Documentation is a gift to future-you

The Meta-Principle

"Make the change easy, then make the easy change." — Kent Beck

Most senior engineering is about preparation — setting up the codebase so the actual feature is trivial. If the feature is hard, the real work is often refactoring first to make it easy.