Skip to content

Release v2.0.0

Choose a tag to compare

View all tags
@Langerrr Langerrr released this 11 Mar 04:36
· 33 commits to main since this release
v2.0.0
0267a46

New Skill: Async State Reasoning

LLMs reason in sequential chain-of-thought and naturally miss concurrent timelines in async systems. The new async-reasoning skill provides structured timeline enumeration — after any state-changing operation, enumerate ALL concurrent read
paths, not just the write path.

Applicable across frontend, backend, and infrastructure — anywhere write and read paths have different latencies.

Includes:

  • 5-step analysis process (data flow mapping, init order, concurrent timeline trace, persistence boundaries, resolution strategy)
  • references/patterns.md — 7 resolution patterns in pseudocode (cancel-set, enabled gating, write-through, event-driven invalidation, optimistic with rollback, disable affordances, sequential init)
  • references/checklist.md — compact checklist for quick use during coding and review

Triggers on: "stale data", "cache invalidation", "optimistic update", "init order", "race condition", "data not updating", "UI shows old data after save", and more.

/plan: Layered Discovery & Scope Assessment

The planning workflow now detects when a feature spans multiple architectural concerns and recommends splitting into separate plans.

Layered Discovery

Phase 1 is now three steps:

  1. Overall discovery — high-level questions only
  2. Scope assessment — identify architectural concerns (presentation, domain logic, data access, infrastructure, integration). If multi-concern, recommend splitting per the separation of concerns principle. Each concern gets its own plan with explicit interface contracts to adjacent concerns.
  3. Domain-specific detail — deep questions per concern, avoiding cascaded question overload

Async State Management in Architecture Design

Phase 3 now prompts for explicit state management design when the concern involves async data flows. Covers:

  • Data flow mapping: source of truth, all read paths, write-to-read latency
  • Init order: dependency graph, gating on prerequisites
  • Concurrent timeline trace: after a write, what happens on ALL read paths simultaneously
  • Persistence boundaries: what survives restarts, what the consumer expects to survive
  • For presentation concerns without a UI mockup: what actions are available/disabled during async gaps

Without explicit state management design, these decisions will be made ad-hoc during implementation and will produce bugs.

Integration Templates

03_integration_summary.md and 04_integration_plan.md are now explicitly generated when the plan includes both backend and frontend work, instead of being silently skipped.

Plan Template

02_plan.md gains a "Frontend State Management" section with tables for data source latency, persistence strategy, initialization order, and user action constraints.

Full Changelog: https://github.com/Langerrr/distributed-architect/commits/v0.2.0

Assets 2
Loading