Inheritance, Conflict & Constraints

DNA isn’t static. It evolves. But evolution isn’t random—it follows rules. This page explains the physics of how your company’s DNA changes and self-organizes.

Inheritance: How Genes Extend

Inheritance is when a new gene builds on an existing one.

Example: Color Hierarchy

Parent Gene: Brand.ColorPrimary
Rule: Brand color is #0066FF (blue)

Child Gene: UI.InteractiveColor
Rule: Interactive elements use Brand.ColorPrimary
Inherits: Brand.ColorPrimary

Grandchild Gene: UI.HoverState
Rule: Hover states darken by 10%
Inherits: UI.InteractiveColor
Calculation: darken(Brand.ColorPrimary, 10%)

When Brand.ColorPrimary changes, all descendants automatically update.

Why Inheritance Matters

Without inheritance:

Change brand color
Manually update 47 places
Miss 3 of them
Product feels inconsistent

With inheritance:

Change brand color (one gene)
All descendants update automatically
Zero manual work
Perfect consistency

Conflict: When Genes Contradict

Sometimes genes contradict each other. This is not a bug—it’s information. Conflicts reveal hidden tensions that need resolution.

Example: Speed vs. Security

Gene: Operations.ShipFast
Rule: Ship features within 2-week sprints
Priority: High velocity

Gene: Security.ReviewRequired
Rule: All code changes require security review (3-5 days)
Priority: Zero vulnerabilities

Conflict: Security review timeline exceeds sprint length

What do you do?

Conflict Resolution Strategies

1. Prioritization

Decide which gene wins.

Resolution: Security.ReviewRequired takes precedence
Outcome: Sprints adjusted to 3-week cycles
Rationale: Security breach costs > slower shipping

2. Synthesis

Create a new gene that satisfies both.

New Gene: Security.FastTrackReview
Rule: Security reviews prioritized for sprint-critical features
  - Daily review slots reserved
  - 2-day SLA for P0 features
  - 5-day SLA for P1 features
Satisfies: Both speed and security needs

3. Context-Dependent

Both genes apply in different contexts.

Resolution: Context-based priority
  - Customer-facing features: Security.ReviewRequired wins
  - Internal tools: Operations.ShipFast wins
Outcome: Split review process by risk level

4. Deprecation

One gene is outdated.

Resolution: Deprecate Operations.ShipFast
Reason: Company maturity, can't sacrifice security anymore
New Gene: Operations.BalancedShipping (includes security in timeline)

Conflict as Signal

Conflicts are valuable. They show:

Where your company is growing
Where old assumptions no longer fit
Where implicit values need to become explicit

Don’t avoid conflicts. Resolve them explicitly.

Constraints: How Genes Limit Each Other

Constraints are when one gene restricts possibilities for another. This isn’t conflict—it’s physics. Some genes naturally limit others.

Example: Tech Constrains UI

Gene: Tech.ResponsiveFramework
Rule: All UI must be mobile-responsive
Constraint on: UI Strand

Impact on UI:
  - Can't use: Fixed-width layouts
  - Can't use: Hover-only interactions
  - Must use: Touch-friendly hit targets (min 44px)
  - Must use: Fluid typography

Tech gene creates boundaries that UI genes must respect.

Common Constraint Patterns

Tech → UI/UX

Tech.Browser Support
  Constrains: UI.Animations (no advanced CSS)
  Constrains: UX.Features (no WebRTC on old browsers)

Tech.Performance Budget
  Constrains: UI.ImageSize (max 200kb)
  Constrains: UX.VideoAutoplay (not on mobile)

Brand → Product

Brand.Positioning ("Premium, not cheap")
  Constrains: Product.PricingStrategy (no low-end tier)
  Constrains: Product.FeatureScope (no "good enough" features)

Security → Data

Security.Compliance (GDPR, HIPAA)
  Constrains: Data.Storage (encrypted at rest)
  Constrains: Data.Retention (delete after 90 days)
  Constrains: Data.Access (audit logs required)

Product → AI

Product.UserControl ("Users always in control")
  Constrains: AI.Autonomy (AI suggests, never decides)
  Constrains: AI.Automation (user approval required)

Why Constraints Are Good

Constraints:

Prevent bad decisions before they happen
Clarify boundaries between systems
Force creativity within limits
Make dependencies visible

Constraints are not limitations—they’re guardrails.

The Constraint Graph

Your DNA forms a directed acyclic graph (DAG) of constraints.

Brand ─→ Product ─→ UX ─→ UI
  ↓         ↓        ↓     ↓
  └────→ Sales    Tech    Data
            ↓        ↓     ↓
         Operations ← AI ← Security

Arrows = “constrains” This graph shows:

Which genes depend on which
What order to make decisions
Which changes will ripple through the system

Constraint Conflicts

Sometimes constraints form impossible situations.

Example: Impossible Triangle

Gene: Product.FeatureRichness
Rule: Build comprehensive features, not MVPs

Gene: Tech.FastShipping
Rule: Ship features in 1-week cycles

Gene: Team.SmallTeams
Rule: Keep engineering teams at 3-5 people

Conflict: Can't build comprehensive features + ship weekly + stay small

This is real tension that needs resolution. Options:

Relax Product.FeatureRichness (ship MVPs)
Extend Tech.FastShipping (2-week cycles)
Grow Team.SmallTeams (hire more engineers)
Reduce Product.FeatureScope (build less)

The constraint conflict forces an explicit strategic decision.

Evolution: How DNA Changes Over Time

DNA evolves through four mechanisms:

1. Mutation (Gene Change)

A gene changes because context changed.

Old Gene: Brand.Voice
Rule: Playful, casual, use emojis

New Gene: Brand.Voice (v2)
Rule: Professional, clear, no emojis
Reason: Target market shifted from consumers to enterprise

2. Insertion (New Gene)

A new gene is added.

New Gene: AI.TransparencyRequirement
Rule: All AI-generated content must be labeled
Context: Regulatory requirement introduced
Impact: Affects Conversation, Product, UI strands

3. Deletion (Gene Removal)

A gene becomes obsolete.

Deleted Gene: Tech.IE11Support
Reason: <0.1% of users, maintenance burden too high
Date Deprecated: Q1 2024
Date Removed: Q2 2024

4. Recombination (Strand Reorganization)

Genes move between strands.

Gene: ConversationTone
Old Strand: Brand
New Strand: Conversation (newly created)
Reason: Conversation became its own system as AI expanded

DNA Versioning

Every change to DNA should be versioned.

Company DNA v2.3.0
Date: 2024-03-15

Changes:
- [BREAKING] Brand.Voice updated (removed emojis)
- [NEW] AI.TransparencyRequirement added
- [DEPRECATED] Tech.IE11Support (removed in v2.4.0)
- [FIXED] UI.ButtonHierarchy clarified (max 1 primary button)

Migration Guide:
- Update all marketing copy to remove emojis
- Add AI labels to product UI
- Remove IE11 polyfills in next release

Versioning lets you:

Track changes over time
Communicate updates to the team
Roll back if needed
Understand why decisions were made

The Self-Organization Property

Here’s the magic: When DNA is explicit, companies start self-organizing.

Engineers check Tech genes before building
Designers reference UI genes before designing
Product checks constraints before proposing features
Sales applies Brand genes when talking to customers

You don’t need to be in every meeting. The DNA guides decisions.

The DNA Equation

Alignment = (Explicit Genes × Active Constraints) / Entropy

More explicit genes → more alignment More active constraints → fewer bad decisions Less entropy → more coherence DNA increases the numerator and decreases the denominator.

Next: Maturity Levels

Now you understand how DNA works. Let’s see where your company sits on the evolution scale.

DNA Maturity Levels

Where your company sits on the evolution scale

​Inheritance, Conflict & Constraints

​Inheritance: How Genes Extend

​Example: Color Hierarchy

​Why Inheritance Matters

​Conflict: When Genes Contradict

​Example: Speed vs. Security

​Conflict Resolution Strategies

​1. Prioritization

​2. Synthesis

​3. Context-Dependent

​4. Deprecation

​Conflict as Signal

​Constraints: How Genes Limit Each Other

​Example: Tech Constrains UI

​Common Constraint Patterns

​Tech → UI/UX

​Brand → Product

​Security → Data

​Product → AI

​Why Constraints Are Good

​The Constraint Graph

​Constraint Conflicts

​Example: Impossible Triangle

​Evolution: How DNA Changes Over Time

​1. Mutation (Gene Change)

​2. Insertion (New Gene)

​3. Deletion (Gene Removal)

​4. Recombination (Strand Reorganization)

​DNA Versioning

​The Self-Organization Property

​The DNA Equation

​Next: Maturity Levels