Know Today

👀 Keep an eye on

• Nested subagents make it more practical for an agent to coordinate dependency-aware implementation work across multiple tickets.
• Specification-to-ticket workflows can parallelize substantial changes while keeping each agent session focused and isolated in a worktree.
• Generated pull requests are becoming an operational interface: runtime evidence, change explanation, and blast-radius classification make review faster and more credible.
• Session retrospectives turn agent traces into data for improving instructions, tools, checks, and repository navigation.
• Teams using shared domain terminology conventions may need to migrate from context.md to glossary.mmd.

🧭 What changed

• Workflow primitives: dedicated implementation, pull-request, and retrospective skills package planning, execution, evidence, and learning into reusable operating patterns.
• Parallel execution: a task graph can identify ready tickets, assign them to isolated worktrees, merge them through an integration branch, and produce one cohesive pull request.
• Evidence-first review: pull-request structure can request tests, screenshots, observable before/after behaviour, and a clear description of affected scope.
• Operational learning: retrospective analysis can surface missing guardrails, context loss, weak tooling, and repeated friction that individual sessions leave behind.

🛠️ Practical workflows

• Represent a feature as a dependency graph, not a flat ticket list; launch only work whose prerequisites are complete.
• Use worktrees for concurrent implementation and an integration branch for combining verified ticket changes.
• Require each pull request to state visible behaviour, executable evidence, change scope, and consequence if the change is wrong.
• Run retrospectives over failed, unusually long, or tool-friction-heavy sessions; convert confirmed findings into compact durable instructions or CI checks.
• Prefer deterministic ticket runners for repeated production workflows, while using agent-led orchestration where the factory infrastructure is still being built.

💭 Opinions worth testing

• Opinion: Ticket-sized agent sessions produce cleaner large changes than asking one agent to carry an entire specification through a long context.
• Opinion: Deterministic ticket loops are the stronger long-term execution model for repeatable engineering work because their behaviour and cost are easier to control.
• Opinion: Agent-managed subagent orchestration is a useful bridge to unattended development when deterministic infrastructure is not yet available.
• Opinion: Human merge throughput is constrained more by reviewer comprehension than by implementation speed, making clear pull-request artifacts a force multiplier.
• Opinion: Claims of correctness from an agent are weak without executable or observable evidence.
• Opinion: Review depth should scale with blast radius and whether a change creates costly external consequences.
• Opinion: Retrospectives should recommend improvements rather than directly changing repositories, since severity and false positives need contextual judgment.
• Opinion: Self-improvement loops can drift into low-value churn when repeated detections trigger repeated automated fixes.
• Opinion: A second-pass analysis of agent sessions can reveal hidden inefficiency that the executing agent never surfaced.

Reflection: Decompose substantial specifications into dependency-aware tickets. Standardize evidence-rich pull requests. Build deterministic runners for recurring flows. Review retrospective findings before encoding them into the environment.

🔮 Predictions to track

• Prediction: Nested delegation will make unattended implementation workflows more usable as agent platforms mature.
• Prediction: Automated retrospective remediation will tend toward runaway low-value changes when false positives are allowed to compound.
• Prediction: Explicit requests for pull-request evidence will often cause agents to run an additional test or capture an additional screenshot.

Reflection: Track nested-delegation quality across real task graphs. Measure evidence coverage in agent-authored pull requests. Gate repository-improvement proposals through contextual triage.

🚀 Build something ambitious

Autonomous change factory for product teams

Outcome: Convert approved product specifications into a continuously operating engineering system that ships cohesive, reviewable changes with less coordination overhead.

Workflow: Ingest a specification, derive a dependency graph, dispatch ready tickets into isolated worktrees, run implementation and tests, integrate compatible changes, generate one evidence-rich pull request, then use completed session data to improve the factory’s instructions and checks. Give agents authority to execute within an approved specification and repository boundary; escalate dependency conflicts, failed verification, and high-blast-radius changes for human decision.

Connected capabilities: coding agents, nested subagents, Git worktrees, task-graph scheduling, test runners, CI, screenshots or runtime checks, pull-request generation, and session-log analysis.

First meaningful milestone: Deliver one multi-ticket feature through the full graph-to-integrated-pull-request path, with every ticket linked to concrete test or runtime evidence.

Engineering-memory operating system

Outcome: Make each agent session improve the next one by turning recurring confusion, tool failures, and missing safeguards into durable repository intelligence.

Workflow: Collect completed execution traces, detect patterns in context loss and friction, propose focused improvements to instructions, terminology, navigation, tool availability, and CI, then feed approved improvements back into future planning and implementation sessions. The compounding asset is a decision record of what repeatedly helped or blocked delivery.

Connected capabilities: session capture, retrospective agents, repository search, skill and instruction files, glossary management, CI configuration, and pull-request evidence.

First meaningful milestone: Analyze a representative set of recent sessions and land a compact set of approved environment improvements that measurably removes repeated friction.

⚡ Fast builds to try

• Evidence-first pull-request template: Add fields for behaviour, tests, screenshots, blast radius, and consequences of failure; get more reviewable agent changes immediately.
• Ticket dependency visualizer: Turn a feature’s tickets and prerequisites into a small graph; identify which work can safely run in parallel today.
• Agent-session friction report: Feed a completed session transcript into a retrospective prompt; receive a prioritized list of missing tools, instructions, and checks.
• Repository glossary check: Create or rename the domain-terms file to glossary.mmd and search dependent instructions; keep agent vocabulary consistent across workflows.

⚠️ Caveats

• Verify: Reported reliability, cost, and quality gains are workflow claims rather than independent benchmarks.
• Verify: Nested delegation, automatic skill invocation, compatibility details, and naming conventions may vary by current platform and tooling.
• Remember: Worktrees, testing discipline, and parallel execution do not establish correctness by themselves; permissions, conflicts, and deployment controls still require deliberate design.

🧠 The author's perspective

The author believes that the day’s incoming information aligns with the view that software development and company operations are becoming increasingly autonomous when agents have a capable runtime, durable instructions, integrations, data, and appropriate authority. A dependency-aware ticket graph, nested delegation, isolated implementation environments, integration, verification evidence, and structured pull requests resemble the planning, implementation, testing, and review loops a harness can coordinate across groups of agents. Session retrospectives further support the idea that real-world execution data can become reusable decision knowledge, improving skills, instructions, tools, and guardrails over time while agents escalate consequential ambiguity for human help instead of waiting passively for prompts.