dev2next 2026: The Context Is the Engineering

Lone Tree, Colorado, had its name before it had a signature tree. The name came from a residential and golf-course development. City leaders planted a 14-foot blue spruce at Lone Tree Parkway and Yosemite Street in 1997.

The city eventually built the context its name implied.

dev2next 2026 ran October 12 through 15 in Lone Tree. Four days of sessions covered architecture, AI, and software delivery. The constraints surrounding a decision emerged as the central theme.

Best practices work inside specific constraints. Architectures serve particular problems. AI output becomes useful when a system supplies boundaries, evidence, and verification. Context shapes every one of those engineering decisions.

Best Practices Have Expiration Dates

Neal Ford and Mark Richards opened with “Why Does Yesterday's Best Practice Become Tomorrow's Anti-pattern?” Successful practices often outlive the conditions that made them useful.

Hungarian notation communicated type information before modern development environments surfaced it automatically. Long-lived branches fit version-control systems that forced teams toward them. Big design up front responded to slow and expensive feedback.

Better tools changed those constraints. Line-by-line comments can discourage expressive code and leave stale explanations behind. Continuous integration and feature flags made shorter branches practical.

Scale can also reverse the advice. DRY reduces duplicated knowledge inside a monolith. Shared abstractions across services can couple teams that need independent deployments. Distributed systems duplicate data to gain locality and resilience.

Slogans create another failure mode. Test coverage becomes engineering theater when the percentage replaces confidence. Heavyweight approval boards correlate with slower and less stable delivery. Microservices add network boundaries before many teams need them.

“An anti-pattern is a good practice whose context died, but the practice is still walking.”

Regular review keeps a sound decision connected to current conditions.

Architecture Makes Tradeoffs Visible

Raju Gandhi's “Exploring Architecture Patterns: A Qualitative Analysis” gave that review process a practical shape. An architecture pattern affects system topology and capabilities. Every pattern exchanges one set of benefits for another.

Orchestration and choreography showed the exchange clearly. A central orchestrator knows the workflow state and can coordinate recovery. Choreography distributes control while requiring each service to understand more events and failure paths.

A multi-broker design can contain failures while increasing cost. A gateway can simplify access while losing FIFO ordering. Architecture records which tradeoffs fit the workload.

Simon Brown's keynote, “The Lost Art of Software Design,” focused on enough up-front design to establish a coherent starting point. Architecture captures significant decisions whose later change would be expensive.

A useful diagram acts like a map. It helps a team discuss communication paths, technology choices, and responsibilities. Richer diagrams produce richer design conversations.

Simon called the starting point a primitive whole. A basic version of the complete idea can evolve coherently. Agile teams still need technical leadership and a shared vocabulary.

Generated Code Still Needs Memory

Josh Cummings explored disposable software in “DRY Is Dead (Sometimes): What Happens When Code Is Cheaper Than Thinking.” He built a daily journal as a self-contained HTML application. Each page gathered current data at build time and could be discarded the next day.

Daily regeneration from an English specification forgot previous lessons. Autosave failed again, integration fields drifted, and controls changed shape. The specification preserved intent while losing implementation knowledge.

Copying the previous application stabilized the interface and preserved fixes. Review prevented old bugs from becoming permanent. Josh's experiment settled on copy-forward plus review.

DRY protects knowledge as much as code. Tests and reviewed examples preserve executable lessons that an ambiguous specification can lose. Cheap generation increases the value of knowing which behavior must survive.

AI Reliability Comes From the Surrounding System

Rustam Mehmandarov's “Taming the Chaos: Security and Predictability in LLM-Powered Applications” applied defense in depth to model interactions. Length checks, PII reduction, and a cheaper local screening model each remove part of the risk. Allowlists and scoped tools constrain what the model can reach.

Critical extraction can use synthetic verification. The model reconstructs the source from its structured result, and the system compares both versions. The extra model call raises token cost while providing evidence of faithfulness.

Deterministic validation should enforce permissions and data rules. Clear verdicts such as accepted, needs review, or rejected make failure safe. MCP tools also need scopes and idempotent writes.

Eric Deandrea extended this approach in “Rethinking Testing Practices in the AI Era.” Evaluations measure whether a model response meets a quality threshold. His strategy covered individual traces, complete sessions, and long-term drift.

A single response can look reasonable while the conversation fails its goal. Session-level evaluation measures sentiment and task completion across the full user journey. Production traces provide strong evidence for future test cases.

Agents Need Certified Data and Declared Authority

Pramod Sadalage and Prem Chandrasekaran opened the final day with “Making Your Data Ready for Agentic AI.” Humans bring unwritten context to a dashboard. They recognize stale tables and suspicious totals. Agents tend to treat every value as truth.

Data contracts and freshness service-level agreements turn those habits into infrastructure. Certified data layers reduce the chance of stale values driving confident actions. Lineage records the data and policy version behind each decision.

Tracing also needs to capture why an agent chose an action. Inputs and timestamps cannot explain a credit decision six months later. The recorded reason closes that audit gap.

Staged autonomy lets each capability earn authority. An agent can begin in shadow mode and move through supervised actions. Reversible operations can advance faster than payments or ledger corrections.

Private data, untrusted content, and outside communication form a lethal trifecta. Removing one side limits exfiltration risk. Declared rules should decide whether a proposed action runs.

Convenience Belongs in the Threat Model

Steve Poole's “curl | bash | hacked: The Unseen Dangers in Your Dev Lifecycle” examined a command copied from official documentation every day. Piping a download into a shell combines retrieval and execution. The user loses the chance to inspect what will run.

Packages, build tools, and GitHub Actions create similar execution paths. Steve demonstrated history suppression, library hijacking, and reverse shells. Malicious code can also exfiltrate data through DNS.

Downloading first creates space for inspection and validation. Workflow changes deserve approval. Containers can limit the reach of third-party code.

AI Workflow Design Should Reduce Friction

Brent Laster's session on AI workflow friction described the verification tax around generated code. Faster drafting can lead to longer review queues and larger pull requests. Developers also lose focus while moving among assistants, chat applications, and review bots.

Brent recommended treating an agent like a confident intern. Give it context, constraints, and a bounded task. Review at checkpoints and expand its scope as it proves reliable.

Persistent context needs the right home. Instructions files carry rules needed in every session. Retrieval finds relevant knowledge, while skills encode repeatable workflows.

Craig Walls connected skills with MCP during a combined community meetup. Skills provide domain workflows. MCP provides controlled access to tools and resources.

Carefully designed MCP capabilities keep context costs small. Five focused tools can serve an agent better than 50 thin API wrappers. Good workflow design reduces friction while preserving clear boundaries.

Leadership and Accessibility Expand the System Boundary

Rachel Kibler's keynote, “Mission Possible: Leading as an Individual Contributor,” framed leadership as a process. It begins when someone sees dissatisfaction and offers a useful direction. Others grant that leadership by choosing to follow.

A leader may raise urgency with facts or lower the temperature by creating space. Communication may provide information, empathy, or a solution. The situation determines which response helps.

Individual contributors can document onboarding, invite quiet voices into a discussion, and mentor peers. These actions create culture and move teams toward a shared vision.

“Documentation is a kindness to those around you.”

Lucia Greco brought the people using the software into the same system view with “Accessibility Across the Whole Software Lifecycle.” Vision, hearing, and motor barriers can be permanent or temporary. Situations such as bright sunlight can create similar barriers.

Accessibility belongs in use cases, design reviews, and testing. Early work costs less than retrofits or emergency remediation. Support tickets provide evidence about barriers that reached production.

Teams can fix a component while the file is open, add accessibility to review checklists, and write missing user scenarios. A placeholder cannot provide a durable field label. Users who enter the use case are more likely to enter the finished product.

Failure Handling Is Architecture Too

Kito Mann's “Expect the Unexpected: Handling Exceptions in Enterprise Applications” connected the conference themes to failure. Recoverable exceptions should be caught, logged, and communicated when appropriate. Other failures should travel to the layer equipped to handle them.

Meaningful exception types preserve domain context. Circuit breakers and bulkheads control how failures spread. Observability shows where the damage began.

Automation increases the value of consistent failure handling. Systems act faster, so their boundaries and recovery paths must be ready before an incident.

Keep Reconnecting the Decision to the Problem

dev2next connected architecture, AI, and team leadership through one durable practice. Engineers need to preserve the reason behind each decision.

Tools improve and constraints disappear. Scale can invert old assumptions. Metrics can replace the outcomes they were meant to represent. Regular review keeps practices connected to the problems they solve.

Lone Tree eventually planted the tree its name implied. Software teams inherit patterns and rules long after the surrounding landscape has changed. Good engineering looks at that landscape again.