A small, public-safe set of links I often share in conversations about field engineering, architecture discovery, domain modeling, and moving from discussion to buildable systems.
- Introducing EventStorming - the canonical book reference.
- Hands-On Domain-Driven Design with .NET Core - Alexey Zimarev's practical DDD book/code repo. Chapter 3 is especially useful as an Event Storming bridge: start with collaborative discovery, capture events/commands/policies in the language of the domain, then use that shared model to shape bounded contexts and implementation seams.
- Domain-Driven Design Quickly - concise DDD primer.
- DDD Reference - Eric Evans' compact reference for DDD terms and patterns.
- Architecture Patterns with Python / Cosmic Python - ports-and-adapters, repositories, unit of work, message bus, and DDD tactical patterns in Python.
- Cosmic Python source code - example repo that accompanies the book.
- 12-factor app - durable baseline for app configuration, dependency, process, and operational design discussions.
- Hypervelocity Engineering (HVE) Core - Microsoft's opinionated collection of Copilot agents, reusable prompts, coding instructions, and validated skills; useful as a pattern library for making AI-assisted engineering repeatable without treating the framework itself as a permanent platform dependency. See also the HVE Guide | HVE Core.
- Engineering Fundamentals Playbook - ISE's public playbook for engineering fundamentals, delivery practices, project setup, quality, and team habits.
- I read 25 system design books; here's what I learned - reading-list style system-design reference.
- I was scared of AI until I read Keith Haring's journals - a useful prompt for talking about tools, creative practice, fear, agency, and doing the work.
- Always bet on text - a durable reminder that plain text is the most portable substrate for thinking, collaboration, debugging, and long-lived systems.
- The lethal trifecta for AI agents - Simon Willison's framing for agent risk: private data, untrusted content, and external communication.
- A primer on elliptic curve cryptography - approachable cryptography background for security and distributed-system conversations.
- Azure Secure Networking for Developers - hands-on Azure network security training for developers covering VNets, private networking, peering, Bastion access, firewall/routing, ASGs/NSGs, and public access patterns.
- Shape Grammar Editor - interactive tool for exploring shape grammars and rule-based generation.
- The Future of Auto Manufacturing: AI Driven Design - design/manufacturing example connected to generative design, constraints, and production workflows.
- Start with the customer's operating model, not the demo: what decisions, actions, and feedback loops change if this works?
- Use Event Storming to identify bounded contexts, command/event flows, policy hotspots, and seams for delivery ownership.
- Treat dashboards/reports as evidence, not the product. The product is a repeatable workflow that changes behavior.
- Separate three motions early: advisory framing, prototype/code-with, and production co-delivery.
- Prefer a thin product-shaped slice over a broad platform-shaped promise.
- Do the right thing, even when the right thing is slower to explain than the flashy thing.
- Listen first. The useful system is usually hidden in the customer's language, workarounds, and pain.
- Untangle before you automate. Tools should reveal the knots, not just make them faster.
- Use simple durable media - notes, events, diagrams, links, plain text - to make thinking visible.
- The work is not to sound smart in the room; it is to leave the room with shared understanding and a next responsible action.
A simple starter for customer gameplans: make the collaboration model explicit before the work gets busy.
- Common goal, clear scope: keep the problem statement, current priorities, and definition of done visible in one shared place.
- One owner per outcome: many people can contribute, but every decision, risk, backlog area, and deliverable needs a named owner.
- Write decisions down: use durable notes, work items, diagrams, and short decision records so the team does not depend on memory or hallway context.
- Collaborate early and often: share rough thinking, prototypes, blockers, and tradeoffs before they are polished.
- Use meetings intentionally: keep a lightweight rhythm for standup, backlog refinement, stakeholder review, and retrospective; cancel or shorten meetings that are not creating shared understanding.
- Bring data to disagreements: prefer customer evidence, usage signals, logs, examples, constraints, and working software over opinion.
- Ask for help quickly: needing help is normal; surfacing uncertainty early reduces surprises and raises quality.
- Protect focus and boundaries: agree on core collaboration hours, response expectations, escalation paths, and what work is intentionally out of scope.
- Keep it simple: choose the smallest useful process, artifact, and architecture that helps the team learn and move responsibly.