Via Positiva vs Via Negativa: The Subtractive Path to Better Engineering

Via Positiva vs Via Negativa: The Subtractive Path to Better Engineering

The Two Paths

Western culture obsesses with addition: add features, add meetings, add processes, add tools, add frameworks. This is via positiva - the path of addition, of doing more.

Ancient wisdom traditions recognized an alternative: via negativa - the path of subtraction, of doing less, of removing obstacles rather than adding solutions.

In philosophy and theology, via negativa (also called apophatic approach) describes God not by what God is, but by what God is not. Rather than making positive claims about ultimate reality, practitioners remove false attributions.

Applied to life and work, via negativa suggests that excellence often comes not from adding more, but from removing what doesn’t work.

Historical Origins

Ancient Stoicism

Stoic philosophers practiced premeditatio malorum (negative visualization) and focused on removing vices rather than adding virtues. Epictetus taught: “It’s not what happens to you, but how you react to it that matters” - remove the mental obstacles, don’t add coping mechanisms.

Buddhist Tradition

Buddhism’s core insight: suffering comes from attachment. The path isn’t adding techniques to manage desire, but removing attachment itself. The Buddha taught via negativa: nirvana is not a thing to attain, but the absence of suffering through the removal of craving.

Nassim Taleb’s Antifragility

Modern thinker Nassim Taleb argues that via negativa is more robust than via positiva. Removing harmful foods from your diet (no processed sugar, no trans fats) is more reliably beneficial than adding superfoods. You know what hurts you more certainly than what helps you.

“The best way to detect a weakness is through negativa via negativa - by removing things one at a time and seeing what fails.” - Taleb

Why This Matters for Engineers

Engineering culture defaults to via positiva:

Via negativa asks: what can we remove?

The subtractive approach often yields better results with less effort.

Practical Applications

1. Code: Subtraction as Architecture

Via Positiva Thinking: “We need a caching layer, a message queue, a service mesh, an API gateway, and a feature flag system.”

Via Negativa Thinking: “What complexity can we remove? Can we eliminate this service entirely? Can we solve this with simpler data structures? Can we remove this abstraction?”

Example: A team spent weeks adding sophisticated caching to improve performance. Via negativa approach revealed they could remove an unnecessary join in their SQL query, eliminating the need for caching entirely.

Code Example - Via Positiva (Adding):

// Adding layers of abstraction
type UserRepository interface {
    GetUser(id int) (*User, error)
}

type CachedUserRepository struct {
    repo  UserRepository
    cache Cache
}

type RateLimitedUserRepository struct {
    repo        UserRepository
    rateLimiter RateLimiter
}

type MetricsUserRepository struct {
    repo    UserRepository
    metrics MetricsCollector
}

// Complex initialization
repo := NewMetricsUserRepository(
    NewRateLimitedUserRepository(
        NewCachedUserRepository(
            NewUserRepository(db),
            cache,
        ),
        rateLimiter,
    ),
    metrics,
)

Via Negativa (Removing):

// Remove abstractions, inline what matters
type UserStore struct {
    db *sql.DB
}

func (s *UserStore) GetUser(id int) (*User, error) {
    // Direct, simple, clear
    var user User
    err := s.db.QueryRow("SELECT id, name, email FROM users WHERE id = ?", id).Scan(
        &user.ID, &user.Name, &user.Email,
    )
    return &user, err
}

When you need caching or metrics, add them. But start by removing unnecessary indirection.

2. Meetings: Subtraction as Respect

Via Positiva:

Via Negativa:

Application: Audit your calendar monthly. For each recurring meeting, ask: “If this meeting didn’t exist, would we reinvent it?” If no, remove it.

3. Decision Making: Subtraction as Clarity

Billionaire Charlie Munger: “It is remarkable how much long-term advantage people like us have gotten by trying to be consistently not stupid, instead of trying to be very intelligent.”

Via Positiva: Add decision frameworks, add stakeholder input, add analysis, add review committees.

Via Negativa: Remove options that are clearly bad. Invert the problem - instead of “How do we succeed?”, ask “How would we fail?” Remove those paths.

Example: Choosing a database:

Often you’re left with 1-2 obvious choices.

4. Personal Productivity: Subtraction as Focus

Via Positiva:

Via Negativa:

Tim Ferriss: “Doing something unimportant well does not make it important. Eliminating something you shouldn’t be doing is more important than doing something you should be doing well.”

5. System Design: Subtraction as Reliability

Via Positiva Failure: A microservices architecture with 47 services, each adding: service discovery, circuit breakers, retries, timeouts, distributed tracing, monitoring, logging, security.

Via Negativa Success: Remove unnecessary service boundaries. Start with a modular monolith. Extract services only when you have evidence they’re needed.

The most reliable systems are often the simplest - because there’s less to break.

Trade-offs and Nuances

When Via Positiva is Right

When Via Negativa is Right

The Balance

Master engineers apply both:

  1. Use via negativa to remove obstacles and complexity
  2. Use via positiva to add value where it matters
  3. Default to subtraction; add intentionally

Reflection Questions

  1. Work: What meetings, tools, or processes could you remove without loss?
  2. Code: What abstractions or dependencies could you delete?
  3. Life: What commitments could you remove to free time for what matters?
  4. Learning: What can you stop learning to focus on what’s essential?
  5. Relationships: What interactions drain energy without adding value?

Implementation Exercise

Week 1: Inventory List everything you do in a week:

Week 2: Subtraction Audit For each item, ask:

Week 3: Remove One Thing Pick the easiest item to remove. Remove it. Observe what happens.

Week 4: Measure Impact Did anything break? Did anyone complain? Did you feel the loss? Or did you gain clarity and time?

Final Insight

The via negativa path is harder than via positiva because it requires saying no - to features, to meetings, to opportunities, to complexity. Addition is default; subtraction requires discipline.

But the reward is profound: systems that are simpler, code that is clearer, decisions that are faster, lives that are more intentional.

As principal engineers, our greatest contribution is often not what we build, but what we prevent from being built. The features we don’t add. The complexity we don’t introduce. The meetings we don’t schedule.

The most powerful designs are those from which nothing more can be removed.

Via negativa isn’t pessimism or minimalism for its own sake - it’s the recognition that in a world of infinite possibilities, the hard part isn’t deciding what to do, but what not to do.

Start by removing what’s clearly harmful. What remains will be stronger.

../