Journeyman · Tools

Grounded tools that do the work

Journeyman’s scaffold fades as you master a skill — and then you build for real. These 8 software-engineering tools are the acting counterpart to the learning loop: describe the problem, get a structured, cited deliverable. Each is grounded in the corpus (Google SRE and the software-engineering cluster) — no invented APIs. Run over REST or MCP.

Architecture Decision Record ↗write_adr

Describe a decision — get a clean ADR (Nygard form).

Corpus-grounded (software-engineering cluster). The standard ADR — title, status, context/forces, the decision, options considered with pros/cons, and consequences (positive + negative) — so the why survives the people.

POST https://peopleanalyst.com/api/bicycle/architecture-decision-record
in  { decision, cluster? }
out title · status · context · decision · options_considered[] · consequences{positive,negative} · riskiest_assumptions
System Design Review ↗review_system_design

Describe a design — get a senior review with risks + recommendations.

Corpus-grounded (software-engineering cluster). A staff-level review: strengths, risks (severity + mitigation), scalability bottlenecks, failure modes, the open questions the design hasn't answered, and prioritized recommendations.

POST https://peopleanalyst.com/api/bicycle/system-design-review
in  { design, cluster? }
out strengths[] · risks[]{severity,mitigation} · scalability_notes · failure_modes · open_questions · recommendations
Incident Postmortem ↗write_postmortem

Describe an incident — get a blameless postmortem with typed action items.

Corpus-grounded (Google SRE via the software-engineering cluster). Blameless: systems/process not people — impact, timeline, systemic root cause, contributing factors, what went well, and action items typed prevent/detect/mitigate.

POST https://peopleanalyst.com/api/bicycle/incident-postmortem
in  { incident, cluster? }
out impact · timeline[] · root_cause · contributing_factors · what_went_well · action_items[]{type,owner_hint}
Tech-Debt Register ↗build_tech_debt_register

Describe a system — get a rated, prioritized tech-debt register.

Corpus-grounded (software-engineering cluster). The real debt rated by impact / effort / risk-if-ignored / priority, the quick wins (low-effort/high-impact), and a payoff sequence — distinguishing debt from missing features.

POST https://peopleanalyst.com/api/bicycle/tech-debt-register
in  { context, cluster? }
out items[]{impact,effort,risk_if_ignored,priority} · quick_wins · sequencing
Code-Review Checklist ↗build_code_review_checklist

Describe a project — get a context-fit code-review rubric.

Corpus-grounded (software-engineering cluster). A review rubric tailored to the stack/team — categories of checks, what BLOCKS a merge vs. what's a NIT, and what to automate so reviewers aren't human linters.

POST https://peopleanalyst.com/api/bicycle/code-review-checklist
in  { context, cluster? }
out categories[]{checks} · blocking[] · nits[] · automation_suggestions
SLO Definer ↗define_slos

Describe a service — get user-centric SLIs, SLOs, and an error-budget policy.

Corpus-grounded (Google SRE via the software-engineering cluster). SLIs that reflect real user experience, SLOs (target + window), an error-budget policy (what happens when it's spent), and burn-rate alerting guidance — targets tied to user need, not 100%.

POST https://peopleanalyst.com/api/bicycle/slo-definer
in  { service, cluster? }
out slis[]{definition,measurement} · slos[]{target,window} · error_budget_policy · alerting_notes
Requirements Extractor ↗extract_requirements

Paste an idea (or book, study, report) — get a PRD-grade, MVP-scoped backlog.

Two LLM passes: source-specific extract, then one strict normalize pass; typed/prioritized requirements with user stories + acceptance criteria; an honest gap report on what's missing or thin.

POST https://peopleanalyst.com/api/bicycle/requirements
in  { input, sourceType: business_idea|deep_research|book|research, sourceId? }
out RequirementCanonical[] + gap report (missing/weak fields)
Application Designs ↗extract_application_designs

Get the technical blueprint — architecture, stack, components, phases — for any idea.

The HOW counterpart to Requirements' WHAT; one canonical design shape regardless of source; implementation phases and dependencies included.

POST https://peopleanalyst.com/api/bicycle/application-designs
in  { text, sourceType?, sourceId?, title?, author? }
out ApplicationDesignCanonical[] (architecture · stack · data model · features · flows · phases)

Homed on the People Analytics toolbox (the “Systems” lane of the 4-S model); the tool pages and REST endpoints live at peopleanalyst.com/tools. ← Back to learning