They introduce a practical framework: the “four buckets” of potential co-founders (family, friends, professional colleagues, and strangers), each with distinct trade-offs. They get vulnerable about their own equity negotiations—including the over-engineered spreadsheet they now find embarrassing—and share why Nick voluntarily gave Julian more equity after their first year working together.

Whether you’re searching for a co-founder, evaluating a potential partnership, or trying to strengthen an existing one, this episode offers a rare, honest look at one of startup life’s most consequential relationships.

Key Topics

• The Four Buckets Framework: Family, friends, professional colleagues, and strangers—each source of co-founders comes with inverse trade-offs between trust depth and ease of exit

• How Nick and Julian Met: Working at Pose, a startup where they were paid to “de-risk” their future co-founder relationship

• Trust as Business Infrastructure: Why high-trust environments are force multipliers for execution speed

• Family Business Dynamics: Julian’s experience watching his father’s restaurant partnership with his uncles dissolve—and why family businesses are more common in high-corruption countries

• Legal Documentation as Trust-Building: The counterintuitive argument that contracts enhance rather than erode trust (”legal debt” vs. tech debt)

• Equity Structure and Vesting: Why every co-founder arrangement needs a vesting schedule with a cliff, and how to think about early work vs. future value

• The Equity Correction Story: How Nick voluntarily gave Julian additional equity after seeing him fully commit—and why Pam (Julian’s wife) still gets emotional about it

• Co-CEO Dynamics: Why Nick sees co-CEO arrangements as a counter signal, and Julian’s evolved take

• Co-Founder vs. Early Employee: What actually distinguishes the two (hint: it’s about risk tolerance and scope, not just timing)

• Vulnerability in Business: Nick’s openness about therapy improving his co-founder relationship

Timestamps

- [00:00] Introduction: The co-founder question Nick gets asked constantly

- [00:59] How Julian ended up at Pose—serendipity vs. intentionality

- [02:39] Why this question deserves deeper analysis

- [03:22] Going to first principles: categorizing potential co-founders

- [04:50] The Four Buckets Framework introduced

- [05:03] Bucket Three: Professional colleagues (how Nick and Julian met)

- [06:19] The “two Julians” confusion at Pose

- [08:42] Advice for young founders: go work on things and meet people

- [09:29] Julian: You also learn about yourself

- [09:33] Exploring other co-founder configurations

- [11:16] Pedigree and baseline trust with strangers

- [11:57] Trust mechanics: inertia and ease of exit

- [12:53] The efficiency of “at-will” business relationships

- [14:09] Julian’s family restaurant story: when family business goes wrong

- [16:09] Why family businesses are more common in high-corruption countries

- [17:50] Nick’s “boy scout” reputation with legal documentation

- [19:12] “Legal debt”—like tech debt, but for contracts

- [19:46] Refocusing on startup co-founder structure

- [20:22] Governance, equity, and vesting schedules explained

- [24:18] The real story: how Nick and Julian structured their first equity split

- [27:45] The over-engineered whiteboard algorithm for equity allocation

- [29:36] Nick gives Julian more equity—Pam’s emotional reaction

- [31:42] Why aligning co-founders matters culturally

- [33:33] The case for 50/50 splits

- [33:53] Solo founders: a future episode topic

- [34:09] Hot takes on the co-CEO phenomenon

- [36:03] Counterpoint: 50/50 as a similar counter signal

- [36:56] The importance of a clear final decision-maker

- [38:36] Equity vs. control: a distinction worth making

- [39:53] When business partnerships feel like marriages

- [41:40] The emotional vulnerability of co-founder relationships

- [42:44] Nick on therapy and its impact on their partnership

- [43:39] Communicating bad news requires trust

- [44:57] Trust as a quantifiable business accelerant

- [46:28] “Trust is a friction reduction agent”

- [48:00] Legal documents as trust-building mechanisms

- [50:14] Co-founder vs. early employee: where’s the line?

- [52:45] Regulatory considerations for 25%+ ownership

- [53:51] Functional distinctiveness as a co-founder marker

- [56:30] Solo founding: scary and overwhelming

- [56:46] The loneliness of CEO responsibilities

- [57:44] The Amsterdam hotel story: bearing bad news alone

- [1:00:05] Nothing kept longer than 24 hours

- [1:01:17] Wrap-up and sign-off

- [1:01:40] Why the podcast is called “Net Good”

Key Quotes

“Dustin Rosen paid us to de-risk our co-founder relationship.”

— Nick, on the value of meeting your co-founder while working at someone else’s company

“When it does happen, it bleeds into everywhere in your life. You cannot separate your work life from your personal life anymore... I didn’t see my cousins at Christmas a couple years because of these fights.”

— Julian, on family business conflicts

“It’s the equivalent of tech debt, but legal debt.”

— Julian, on skipping legal documentation in family businesses

“Almost always the person that has done all that very valid, very difficult work is overvaluing the work they’ve done to date. And if they are truly bringing on a genuinely valuable co-founder, they are undervaluing all the stuff that’s going to happen in the future.”

— Nick, on equity allocation psychology

“I didn’t ask for it. You just showed up one day and you were like, hey, we should talk. And then you handed me a piece of paper... I’m not gonna say no, but thank you.”

— Julian, on Nick voluntarily granting him additional equity

“If someone, if you feel strongly about another human being enough to say, start this thing with me, walk away from your perfectly sane and good job and do this crazy thing with me—and if they are crazy enough and have enough trust in you to say yes—that 50-50 or whatever the even split is, is often the fastest, most aligned and most directionally accurate arrangement you can come to.”

— Nick

“A co-founder is somebody who is willing to—it doesn’t matter what it is, it doesn’t matter if it’s sweeping the floors in the office, I’m gonna do it if it has to be done.”

— Julian, on what distinguishes co-founders from employees

“Trust is a friction reduction agent.”

— Nick

“If I’m working on something and you’re interested in what I’m working on and the price is half of my ownership, I don’t give a shit, let’s go. Let’s go have some fun.”

— Nick, on partnership

Key Takeaways

1. The Four Buckets have inverse trade-offs: Family and friends offer deeper initial trust but are harder to exit; strangers are easy to walk away from but require trust built from scratch. Professional colleagues may be the sweet spot.

2. Working together before founding together is valuable: Nick and Julian spent nearly two years as colleagues at Pose before starting their first company. That time was essentially subsidized co-founder vetting.

3. Always use vesting schedules with cliffs: No matter what equity split you agree to, tie it to a four-year vesting schedule with a one-year cliff. Catastrophic co-founder problems will be visible in the first 12 months.

4. People overvalue past work and undervalue future work: The founder who’s been working alone for a year often over-weights that contribution relative to the years of work ahead.

5. 50/50 is often the right answer: If you trust someone enough to ask them to quit their job and join you, nickel-and-diming over equity percentages may be wasted energy. Course correct later if needed.

6. Clear governance matters more than equity split: Having a designated final decision-maker (and documenting it) is more important than whether you’re 50/50 or 60/40.

7. Legal documentation builds trust: Going through the process of writing things down creates clarity and reduces future friction—it’s trust-enhancing, not trust-eroding.

8. Vulnerability is a business asset: Nick credits therapy with improving his co-founder relationship. The ability to share bad news quickly depends on trusting your partner won’t “crush you” for it.

Like what you heard? Share this episode with a founder who’s thinking about partnership.

Net Good is a podcast about building companies, making decisions, and trying to leave things better than we found them.

Starting with a simple thought experiment about stealing cars versus copying code, the conversation unpacks how software’s unique physics—zero marginal cost, infinite replicability, and decoupling from physical scarcity—breaks the mental models that underpin capitalist economics. From Netflix’s DRM workarounds to Wikipedia’s invisible contribution to GDP, they explore why our existing frameworks struggle to measure or incentivize the abundance that software creates.

The episode doesn’t offer easy answers. Instead, it surfaces deeper questions about platform ownership, value measurement, and whether we’re stuck in an unstable equilibrium between old and new economic realities.

Key Topics & Timestamps

Defining Capitalism (00:00-05:30)

• Private ownership and control of means of production

• Market-based resource allocation

• Price as information signal (Hayek)

• Profit motive and capital accumulation

• Legal frameworks for property and contracts

Software’s “Code Smell” Problem (05:30-12:00)

• Introduction to “code smells” as heuristics in software development

• DRM (Digital Rights Management) as symptom of deeper incompatibility

• Why software breaks traditional property models:

  • Infinite replicability at near-zero marginal cost

  • Non-rivalrous consumption (copying ≠ theft in traditional sense)

  • No natural scarcity

The Netflix Paradox (12:00-18:00)

• How streaming services artificially create scarcity

• The technical absurdity of DRM: downloaded content that artificially self-destructs

• Why companies must spend resources to *prevent* abundance

• The contradiction of paying to make your product worse

Marginal Cost and Market Failure (18:00-25:00)

• Traditional economics: price approaches marginal cost in competitive markets

• Software’s marginal cost: effectively zero

• **The problem**: Zero-price equilibrium means creators can’t recoup R&D costs

• Why this breaks the incentive structure of capitalism

• First-mover advantage as temporary solution (but unsustainable)

The Wikipedia Case Study (25:00-30:00)

• From thousand-dollar encyclopedia sets to free, universal access

• The measurement problem: billion-dollar industry → zero → looks like value destruction

• Reality: Massively increased access, frequency, and utility

• Question: Are we systematically under-counting software’s contribution to GDP and productivity?

Platform Power & Feudal Futures (30:00-35:00)

• The “one foot in old world, one foot in new” instability

• Risk of neo-feudalism: Platform owners control entire stack, everyone else rents

• Why this feels wrong but lacks obvious solutions within capitalist framework

• Star Trek economics as thought experiment (post-scarcity, post-money)

Beyond the Binary (35:00-38:00)

• Rejecting the capitalism-communism spectrum as the only option

• Call for more creative thinking about economic systems

• Acknowledgment that we’re pattern-matching to old models when we need new ones

Hot Take: AI Isn’t Software (38:00-End)

• Julian’s provocation: Current generative AI is fundamentally different from software

• Unlike true software, AI is tightly coupled to hardware economics

• Suggests AI might be a new species of thing—neither pure software nor hardware

Key Insights

On Software’s Unique Physics:

“If I steal your car, you don’t have a car anymore. If I steal your code base though, you’ve still got a code base, but we would still call that theft. So what does that tell us about the ways that the physics of software break our understanding and mental model of capitalism?”

On Artificial Scarcity:

“The software is good enough to do what you want it to do, but then you have to pay people to make it not do something that it could otherwise easily do. That’s broken. That’s a broken incentive structure.”

On the Measurement Problem:

“The deflationary pressure [of software] is so strong in a way that could create such abundance and could create such high quality of life, but that’s so difficult to measure, it breaks all of our instrumentation.”

On Platform Feudalism:

“I’m worried the new world looks like medieval France where a few platform owners and their shareholders own the entire stack of our civilization and we all just are visitors here. We’re all renting everything and that feels wrong.”

On Economic Creativity:

“There has to be more creative things we can come up with for economic systems than just that one spectrum [capitalism to communism]. There has to be something else.”

---

## Concepts Explained

**Code Smell**: A heuristic in software engineering indicating structural problems. Examples include functions that are too long or logic that’s copy-pasted across multiple locations. Suggests future maintainability issues even when code currently works.

**Digital Rights Management (DRM)**: Technologies designed to control how digital content can be used after purchase. The hosts argue DRM represents an artificial constraint imposed to maintain scarcity-based business models despite software’s natural abundance.

**Marginal Cost**: The cost of producing one additional unit. In traditional manufacturing, this includes materials and labor. For software, marginal cost approaches zero after initial development, creating fundamental problems for price-based markets.

**Zero-Sum vs. Non-Zero-Sum**: Traditional physical goods are zero-sum (if you have the bicycle, I don’t). Software is non-zero-sum (we can both have copies of the same program without diminishing each other’s copy).

**Externalities**: Economic side effects not captured in market prices. The hosts suggest software creates massive positive externalities (like Wikipedia) that are invisible to GDP measurements.

Related Concepts to Explore

• Information wants to be free (Stewart Brand)

• The abundance vs. scarcity dichotomy in digital goods

• Open source economics and sustainability

• Universal Basic Income as response to automation

• Public goods and the free rider problem

• The tragedy of the commons (and anti-commons)

• Platform capitalism and network effects

• Post-scarcity economics

• The knowledge economy and intangible assets

Recommended Reading & References

• Snow Crash by Neal Stephenson (mentioned: dystopian hyper-capitalist future)

• Friedrich Hayek’s work on price signals and information

• Marc Andreessen’s “Software is Eating the World”

• Chris Anderson’s “Free: The Future of a Radical Price”

About Net Good

Startup life is messy. Founders Julian Vergel de Dios and Nick Dazé share candid stories about building technology. From emerging trends and tech predictions to personal failures and philosophy, Net Good explores how entrepreneurship works.

Key Topics

Defining Vibe Coding

• The spectrum from deliberate LLM use to pure vibe coding

• Why most people conflate any LLM-assisted coding with vibe coding

• Julian’s approach: granular prompting with manual review of every change

• Nick’s front-end fluency vs. back-end experimentation

The Hidden Costs of LLM-Generated Code

• Why the first shot often works but subsequent iterations fail

• The “five different engineers” problem: inconsistent patterns and architecture

• Real productivity math: 2 days design + 1 day vibe coding ≠ time saved when Julian spends 5+ days fixing it

• The emotional cost of working in a codebase with no coherent structure

Context Windows: The Promise vs. Reality

• Million-token context windows sound impressive, but hit practical limits fast

• Why stuffing PDFs and user research into context doesn’t scale linearly

• The human advantage: we’re constrained by time, not context window size

• Retrieval Augmented Generation (RAG) as a workaround: loading only relevant context

The Junior Developer Crisis

• Market dynamics: companies betting that 20-30% productivity gains from senior engineers replace junior hires

• The pipeline problem: if we stop training juniors today, who will become the senior engineers tomorrow?

• Short-sighted cost-cutting vs. long-term talent development

• Current state: top CS graduates with debt and no job offers

Economic Viability Check

• Julian’s estimate: 20-30% more productive, worth $20/month but not $10,000/month

• The subsidization question: what happens when real costs emerge?

• Factor of 9 rule: improvements need to be 9x better to overcome switching costs

• LLMs are useful, but they are hitting diminishing returns on training improvements

Legal Liability in the AI Age

• The Tea app disaster: vibe-coded dating app leaked 30,000 driver’s licenses

• Liability doesn’t disappear with AI—you’re still accountable for what you ship

• The airlock problem: compressing corporate liability layers into solo founders

• Missing legal framework: should AI be able to earn money, execute contracts, and assume liability?

How LLMs Actually Work (And Why It Matters)

• Next-token prediction and probability distributions

• Context poisoning: why long, contradictory contexts flatten output quality

• The “throw away context” strategy: starting fresh vs. course-correcting

• Genesis prompts vs. iterative refinement

Best Use Cases Discovered

• Test case generation: LLMs excel at creating comprehensive test coverage

• Design placeholder content: realistic, varied fake data at scale

• Error debugging: handling Node version conflicts and library incompatibility

• Non-critical backend work that doesn’t need optimization

Key Takeaways

1. Vibe coding works for prototypes and personal projects, not production code that others must maintain. The time saved upfront gets consumed (and then some) when engineers have to refactor poorly architected code.

2. LLMs are 20-30% productivity boosters for experienced engineers, not replacements. The math only works at current subscription prices ($20/month), not at true compute costs.

3. The junior developer market collapse is short-sighted. Today’s cost savings create tomorrow’s talent shortage—LLMs aren’t good enough to replace the senior engineers who will retire in 5-10 years.

4. Context window size ≠ usable context. Million-token windows sound impressive, but practical limits hit much sooner due to file formats, content quality, and context poisoning.

5. Legal liability is the non-obvious barrier to AI-generated code at scale. We lack frameworks for who’s accountable when autonomous agents make costly mistakes.

Pull Quotes

Julian on vibe coding: “The LLM basically goes like, I just need to satisfy this and get it to this point, it doesn’t matter how I get there as long as it does the thing.”

Nick on the junior developer crisis: “If we’ve destroyed the pipeline of junior engineers that over time become the mid and senior architects, that’s a big problem.”

Julian on context poisoning: “The longer the context window gets and the more self-contradictory or nonsensical that the content within the context window gets, the flatter the distribution will get and the more likely you will be to get garbage output.”

On economic viability: “If I’m paying 20 bucks a month for that extra 20 to 30%, I definitely wouldn’t say it’s worth it [at $10,000/month]. I'd better be picking up some extra money from my job.”

Resources & Concepts Mentioned

• Claude Code (command line tool for agentic coding)

• Retrieval Augmented Generation (RAG)

• Context windows: Claude Opus 4.1 (1M tokens ≈ 1,500 pages)

• The Tea app data breach incident

• The factor of 9 rule for overcoming switching costs

Teaser for Next Episode

“Is software fundamentally incompatible with capitalism?” — Julian drops a fire question about open source, value creation, and economic systems that demands its own episode.

Startup life is messy. Founders Julian Vergel de Dios and Nick Dazé share candid stories about building technology. From emerging trends and tech predictions to personal failures and philosophy, this podcast explores how entrepreneurship works.

Key Topics Covered

The Reality of VC Decision Making [00:02:30]

• The stark disconnect between venture capital marketing ("we back visionary entrepreneurs with napkin ideas") and actual investment criteria

• Why most VC decisions fall into just three buckets: hype, metrics, or rejection

• How this differs dramatically from the "intrepid explorer" narrative VCs promote

The Founder-Investor Prisoner's Dilemma [00:15:45]

• Why getting clear feedback from investors is nearly impossible

• How VCs preserve future optionality by avoiding direct rejections

• The cognitive load of selling to three different audiences: customers, employees, and investors

What Makes a Venture-Scale Business [00:35:20]

• Why your business needs potential for 1000x returns, not just steady growth

• The "one in ten people on the planet" addressability test

• Common mistakes founders make when evaluating VC fit

PocketList Deep Dive [00:28:00]

• The original concept: a "give-to-get" social network for apartment hunting

• Novel approach to leveraging departing tenant knowledge

• Customer acquisition vs. inventory acquisition costs

• Multiple business model pivots and why each failed

The Perfect Storm of Failure [00:52:15]

• COVID-19 eviction moratoriums

• iOS 14.5 privacy changes destroying user acquisition economics

• Market structure challenges in real estate

Key Insights

On Fundraising Strategy:

• "You're not courting 100 investors. You're looking for one lead."

• FOMO is the most powerful force in venture capital

• Never build for investors instead of customers once you've raised money

On Business Model Validation:

• The frequency problem: PocketList users only needed the service once per year vs. restaurants getting 70 customers per night

• Real estate market stratification made finding the right customer segment nearly impossible

• Unit economics must work at every tier of your target market

On Founder Psychology:

• Good entrepreneurs become "jittery" when they go more than a week without customer contact

• The dangerous trap of optimizing for investor signal instead of market signal

• Managing the complexity of simultaneous customer, employee, and investor relationships

Lessons for Aspiring Founders

1. Understand VC incentives: Most investment decisions are about hype or undeniable metrics, not founder grit or innovation

2. Test venture fit early: If your business can't plausibly serve millions of people, consider alternative funding paths

3. Preserve customer focus: The biggest risk after raising money is building for investors instead of users

4. Expect information asymmetry: You won't get honest feedback from investors due to structural incentives

About the Hosts

Nick Dazé and Julian Vergel de Dios are serial entrepreneurs who have collectively raised and managed over $10 million in venture capital across multiple startups. They share hard-won insights from both successful funding rounds and spectacular failures.

What's Next

The hosts hint at discussing their current ventures and exploring failure analysis across other companies. The podcast format and name are still evolving as they find their rhythm.

If you found value in this episode, please share it with a fellow founder who might benefit from these hard-earned lessons.