The deceptive nature of growth and the AI durability framework Growth is often a mask that hides fundamental failures within a business. In the current venture climate, hyper-growth can blind investors to underlying structural issues, leading to catastrophic miscalculations. Miles Clements, Partner at Accel, argues that the only way to avoid these traps is a rigorous evaluation of "time to value" versus the "durability of value." This framework separates transient novelties from generational platforms. Take the contrasting examples of legal or accounting AI versus "vibe coding" apps. AI tools for professional services often suffer from slow adoption cycles; selling to lawyers and accountants is a grind. However, once integrated, the durability of that value is transformational. Conversely, early vibe coding apps offer instant gratification—the weekend warrior can build a functional app overnight—but they often lack long-term retention because the value doesn't compound. The coding vertical has become the primary battleground in AI because it satisfies both ends of the spectrum: developers see productivity gains within hours, and the utility scales exponentially as teams integrate the tools into their core workflows. Cursor remains the engineering platform of record despite Twitter noise The "Cursor is dead" narrative, fueled by competitive moves from Claude Code and public criticism from high-profile figures like Chamath Palihapitiya, ignores the sheer scale of the company's market expansion. While Anthropic's Claude Code has captured the zeitgeist, the market for AI-assisted engineering is not a zero-sum game. Clements highlights that these tools are bringing entire cohorts of new developers online and radically increasing consumption per user. Critics often point to Cursor's reliance on external models or its perceived high cost, but the metrics tell a different story. The company recently surpassed $2 billion in Annual Recurring Revenue (ARR), a figure that signals unprecedented product-market fit. Furthermore, Cursor is successfully transitioning from a feature-based IDE to an agent-driven platform. Data indicates that 90% of Cursor users are daily active users of the agent product, which grew 15x over the last year. By the time most observers realized Cursor was a player, it had already begun building specialized coding models to ensure enterprise-grade performance that generalist models cannot match. Learning from the sting of missed generational founders No venture firm has a perfect track record, and Miles Clements is candid about the misses that haunt Accel. Two specific examples—ServiceTitan and Rippling—illustrate the dangers of rigid adherence to traditional valuation rules. In the case of ServiceTitan, Accel hesitated on a round in the $250 million range because of strict internal caps on vertical SaaS multiples. The company eventually reached a $9 billion valuation. The lesson was clear: if you understand the depth of market disruption, you must be willing to break the rules on price. Rippling represents a different kind of miss—one rooted in an underestimation of what Clements calls the "marginal ease of ARR accumulation." Parker Conrad demonstrated a unique ability to capture margin in areas others ignored, such as laptop provisioning and IT leasing, turning them into high-growth revenue lines. While Accel stuck to its "knitting" regarding ownership thresholds and valuation caps, the reality is that generational founders like Parker Conrad deserve a different playbook. In a hyper-competitive market, the "science" of valuation must occasionally yield to the "art" of recognizing when a founder is operating on an entirely different plane. The shifting mechanics of venture ownership and exits The traditional venture model—investing at the Series A to secure 20% ownership and riding it to an IPO—has been inverted. In today's market, firms must often "ladder" their way into a significant position. This involves sponsoring tenders, participating in growth rounds, and buying into the IPO. This multi-stage approach is essential when dealing with companies like Stripe or DataBricks that stay private longer. This delay in going public is a rational response to the current state of the public markets, which Clements describes as increasingly irrational and "casino-ized." When a single security report or a macro shift can wipe out billions in market cap regardless of company fundamentals, founders naturally prefer the relative stability of private secondary markets. For the top tier of private companies, the public market's traditional benefits—employee liquidity and M&A currency—are now readily available through private tenders. Consequently, the threshold for a successful IPO has moved; companies now need a clear line of sight to a $5 billion market cap and beyond to escape the "murky" middle ground where smaller public stocks are often ignored or oversold. Why founder conviction is the ultimate signal In a world where technology is transient, the founder remains the only durable asset. Miles Clements emphasizes that when a founder's conviction wanes, the investment thesis usually dies with it. This is why Accel continues to double down on companies where the original visionaries, like Mike Cannon-Brookes at Atlassian, remain at the helm. These leaders possess the resilience to navigate the "humbling" reality of market cycles and the emergence of disruptive technologies like AI. The venture business remains a human one. Success isn't just about picking the right sector; it’s about the professional standard maintained over decades. This involves a commitment to the "rituals" of the firm—the partner meetings and portfolio reviews—that keep investors grounded when the market gets euphoric. While the tools of the trade have shifted from issue tracking to autonomous agents, the core requirement remains the same: identify the outliers who are building for a ten-year horizon, not just the next fundraising cycle. The future belongs to those who can distinguish between a momentum-chasing fad and a platform with the structural integrity to compound for decades. Implications for the next decade of innovation The AI revolution is not over; it has barely entered its first true compounding phase. The belief that the "generational" bets in AI were all made years ago is a fallacy that Clements has since rejected. While early foundation model investments like OpenAI and Anthropic were massive, the application and agent layers are just beginning to take shape. We are moving toward a world where software replaces labor directly, rather than just augmenting it. This shift demands a change in investor mindset—looking for outcomes that aren't just $1 billion exits, but $100 billion platforms. The goal is no longer to find a company that hits a double; it is to find the ones capable of rewiring the entire global economy.
Linear
Products
- Mar 9, 2026
- Feb 21, 2026
- Feb 5, 2026
- Jan 5, 2026
- Sep 17, 2025
Overview of the Pest 3.0 Evolution Testing in the PHP ecosystem transformed when Pest PHP first arrived, bringing a functional, human-readable syntax to a world dominated by verbose object-oriented boilerplate. With the release of version 3.0, the framework moves beyond mere test execution and into the realm of full-spectrum development workflow. Created by Nuno Maduro, Pest 3.0 addresses the psychological and practical gaps in the testing process: managing unfinished work, maintaining architectural integrity across teams, and verifying that tests actually provide the security they claim to offer. These features aren't just aesthetic upgrades; they represent a shift toward making the test suite the central source of truth for a project's health and roadmap. Prerequisites To get the most out of this tutorial, you should have a solid grasp of the following: * **PHP 8.2+**: Modern PHP features are central to the framework's performance. * **Basic Testing Concepts**: Familiarity with assertions, mocks, and the red-green-refactor cycle. * **Laravel Framework**: While Pest works with any PHP project, its integration with Laravel is seamless and highly optimized. * **Composer**: Knowledge of package management to handle updates and dependencies. Key Libraries & Tools * Pest PHP: The core testing framework focused on developer experience. * **Linear**: A task management tool often used alongside Pest for tracking project progress. * **Sublime Text**: The editor used for demonstration, though VS Code or PhpStorm are equally supported. * **PHPUnit**: The engine under the hood that Pest abstracts into a more elegant syntax. Integrated Task Management One of the most friction-heavy parts of development is the context switch between a code editor and a project management tool like Linear or GitHub Issues. Pest 3.0 bridges this gap by turning your test suite into a task manager. Previously, developers used the `todo()` method to mark a test for future implementation. Now, you can assign these tasks directly to team members and link them to specific issue IDs. Implementation Walkthrough You can chain methods to define the owner and the reference point for any pending test. This keeps the technical debt visible right where the code lives. ```php it('allows users to edit their profile') ->todo(assignee: 'Nuno Maduro', issue: 11); ``` When you have several related tasks, you can avoid repetition by grouping them within a `describe` block. By chaining `todo` to the block itself, every test within that scope inherits the status. ```php describe('User Management', function () { it('can create a user'); it('can delete a user'); })->todo(assignee: 'Taylor Otwell', issue: 22); ``` When a feature is complete, simply swap `todo()` for `done()`. This keeps the metadata—who built it and why—intact within the codebase. If the test fails months later, the original context is instantly available to whoever is debugging. Architectural Presets for Code Consistency Architectural testing ensures that your project's structure remains consistent, preventing "leaky abstractions" or improper dependencies. Pest 3.0 introduces **Presets**, which allow you to apply hundreds of industry-standard rules with a single line of code. This is a massive improvement over manually writing granular rules for every new project. Using the Presets Instead of writing individual expectations, you call the `arch()->preset()` method. For example, the `php` preset ensures you aren't using dangerous functions like `eval()` or leaking environment details via `phpinfo()`. ```php // tests/ArchTest.php arch()->preset()->php(); arch()->preset()->security(); ``` For Laravel developers, the `laravel` preset is particularly powerful. It enforces resourceful controller naming conventions and ensures that exceptions correctly implement `Throwable`. ```php arch()->preset()->laravel(); ``` Pest also caters to different coding philosophies with `strict` and `relaxed` presets. The `strict` preset might demand `final` classes and private methods, while `relaxed` allows for more flexibility, ensuring that whichever style you choose remains consistent across the entire application. Mutation Testing: The Truth About Coverage Traditional code coverage is often a deceptive metric. It tells you which lines of code were *executed* during a test, but it doesn't prove that your tests would actually catch a bug if those lines were changed. **Mutation Testing** solves this by intentionally breaking your code (creating "mutants") and seeing if your tests fail. If the code changes but the tests still pass, the mutant has "escaped," and your test quality is poor. Running a Mutation Test To run mutation testing, use the `--mutate` flag in your terminal. Pest will analyze your source code, apply mutations (like changing a `public` method to `protected` or removing a database save call), and rerun the tests. ```bash ./vendor/bin/pest --mutate ``` If Pest removes a critical line—such as `$user->save()`—and your tests still pass, the output will show a diff of the mutation. This highlights exactly where you need to add more meaningful assertions rather than just "hitting" the line to satisfy a coverage percentage. Syntax Notes & Best Practices * **Higher-Order Assertions**: Pest encourages chaining methods like `->expect()->toBe()` for readability. * **Parallel Execution**: When running mutation testing, always use the `--parallel` flag. Mutation testing is computationally expensive because it reruns the suite many times; parallelization keeps the feedback loop fast. * **Context over Coverage**: Don't aim for 100% code coverage; aim for a high mutation score. The latter proves that your assertions are actually verifying logic. Tips & Gotchas * **Zero Breaking Changes**: Upgrading from Pest 2.0 to 3.0 is a simple `composer update`. The team prioritized backward compatibility despite the major version bump. * **Filtering**: When debugging mutation failures, use filters to run mutations against a specific file to save time: `pest --mutate --filter=PasswordController`. * **Avoid Over-assignment**: While Task Management is powerful, don't let your test suite become a dumping ground for every minor idea. Use it for tasks that require a specific technical implementation.
Sep 3, 2024