Jared Palmer is a highly influential software engineer, entrepreneur, and executive known for creating foundational React ecosystem tools like Formik, TSDX, and Turborepo. As the former VP of AI at Vercel and current VP of Product for CoreAI at Microsoft, he has consistently focused on improving developer experience and pioneering the concept of "Generative UI" with tools like v0. The following lessons capture his core philosophies on building resilient, high-performance tools and navigating the evolving intersection of AI and software development.

Part 1: On Formik and State Management

  1. On Form Complexity: "Forms are hard." — Source: [Formik Documentation]
  2. On React Idioms: "Formik was built to keep form state local and React-centric, moving away from the heavy global abstractions of Redux-form." — Source: [Reactiflux AMA]
  3. On Error Handling: "Write a small function that transforms your backend error into the same shape as Formik's errors and then call `setErrors`." — Source: [Medium]
  4. On Context Usage: "Use this hook if you're Jared." — Source: [Formik GitHub]
  5. On Validation: "Validating forms shouldn't require you to rethink your entire component architecture; it should be as simple as passing a schema or a function." — Source: [Syntax Podcast]
  6. On Developer Ergonomics: "The goal of Formik was to make form building in React 'tear-free' by eliminating the repetitive and annoying wiring." — Source: [YouTube Tech Talk]
  7. On Hooks Integration: "Migrating to React Hooks in Formik 2 allowed us to dramatically reduce boilerplate and make the API feel much more native to modern React." — Source: [PodRocket]
  8. On State Placement: "Keep your form state close to where it is used. Don't hoist it to a global store unless absolutely necessary for cross-route persistence." — Source: [Dev.to]
  9. On Controlled Components: "React's controlled components are powerful, but wiring up `onChange` and `onBlur` for every single input is what makes forms tedious." — Source: [Formik Documentation]
  10. On Abstraction Limits: "A good form library provides the rails to guide you, but gets out of your way when you need to build complex, custom input behaviors." — Source: [iJS Conference]

Part 2: On Turborepo and Build Systems

  1. On Build Efficiency: "Never do the same work twice." — Source: [Turborepo Dev]
  2. On Monorepos: "Turborepo is a monorepo build system and orchestrator... it wasn't about making things necessarily faster or just making them smarter." — Source: [Fireside.fm]
  3. On Naming: "Turborepo is like monorepo but with Turbo." — Source: [PodRocket]
  4. On Caching: "Remote caching acts like a Dropbox for your build folder. If a teammate or CI already built it, you just download the result." — Source: [Vercel Blog]
  5. On Using Rust: "We migrated Turborepo to Rust to ensure the build system is not only blazingly fast but mathematically safe and correct." — Source: [Vercel Live Stream]
  6. On Task Scheduling: "A smart build system must understand the dependency graph of your tasks to orchestrate them in parallel optimally." — Source: [Earthly Blog]
  7. On Developer Velocity: "The primary goal of Turborepo is to make 'ship happen' by completely removing the friction and idle time of slow builds." — Source: [Madrona Ventures]
  8. On Legacy Tools: "Tools like Lerna paved the way, but modern codebases needed a system that understood caching and incremental execution at a fundamental level." — Source: [LogRocket]
  9. On the Turbo Engine: "Aligning Turborepo and Turbopack on a shared Rust-based 'Turbo' engine allows us to build a deeply integrated and lightning-fast developer experience." — Source: [Vercel Changelog]
  10. On Incremental Adoption: "A good build tool shouldn't require you to rewrite your entire project. You should be able to drop it into an existing workspace and see immediate gains." — Source: [GitHub]

Part 3: On Developer Experience (DX) and Tooling

  1. On Zero-Config Tooling: "With TSDX, the goal was to provide a zero-config CLI for TypeScript package development so authors can focus on code, not configuration files." — Source: [TSDX GitHub]
  2. On the 'Just React' Philosophy: "Tools should feel like natural extensions of the React API rather than heavy, opinionated abstractions." — Source: [Reactiflux]
  3. On Scratching Your Own Itch: "Most of my open-source projects started because I was running an agency and kept running into the exact same painful bottlenecks on every project." — Source: [YouTube Interview]
  4. On TypeScript Adoption: "First-class TypeScript support is no longer a nice-to-have; it's a fundamental requirement for modern tooling to provide a world-class DX." — Source: [Syntax Podcast]
  5. On SSR Configuration: "Razzle was built to abstract the complex Webpack configuration needed for Server-Side Rendering into a single dependency, similar to Create React App." — Source: [Razzle Docs]
  6. On Removing Boilerplate: "Developer experience is heavily dictated by how much repetitive, mindless wiring a tool forces you to do before you can actually start building." — Source: [Dev.to Article]
  7. On Seamless Transitions: "The transition from local development to production should be as transparent and frictionless as possible." — Source: [Vercel Keynote]
  8. On Tool Constraints: "Opinionated tools are great because they limit your choices in a good way, saving you from decision fatigue on architectural trivialities." — Source: [iJS Conference]
  9. On Tooling Maintenance: "The true cost of complex Webpack or Rollup configs isn't writing them the first time; it's maintaining them as the ecosystem evolves." — Source: [PodRocket]

Part 4: On v0 and Generative UI

  1. On Defining the Space: "We call it Generative UI—combining the best practices of frontend development with the potential of generative AI." — Source: [SDTimes]
  2. On the Goal of v0: "Our goal is to help developers build the first iteration of their product effortlessly." — Source: [Vercel Blog]
  3. On Component Generation: "v0 is the next evolutionary step; it uses AI to construct React components on the fly, just in time, before streaming it back to the user." — Source: [YouTube Demo]
  4. On Workflow Efficiency: "The idea with v0 is not to be pixel-perfect initially, but to get you to your first version where you can just copy-paste and ship." — Source: [Simon Willison's Blog]
  5. On the v0 User Experience: "From now on, we're also showing v0's full output in every response. This is a much better UX because it teaches end users how to prompt more effectively." — Source: [Latent Space]
  6. On Design Systems: "By combining AI with established design systems like Tailwind CSS and Shadcn UI, we ensure the generated code is actually usable and idiomatic." — Source: [v0.app]
  7. On Iterative Prompting: "Generative UI isn't a one-shot process. It's a conversation where you generate, select a version, and continuously refine it within the tool." — Source: [Vercel AI SDK Docs]
  8. On Accessibility: "Continuing to grow v0 will bring everyone one step closer to industry standards for inclusive and accessible user interfaces." — Source: [YouTube Keynote]
  9. On Bundle Size: "The end result with v0 is fully generative on-demand user interfaces without compromising on performance or bundle size." — Source: [GreatFrontEnd]

Part 5: On AI and the Future of Software

  1. On the Evolution of Modalities: "We've gone from text to UI, to now we're at this 'text to app' modality, and I think we're going to get to 'text to business' in the future." — Source: [Substack]
  2. On Learning to Code: "I would still learn to code. There'll always be a market for people who get things done and understand the underlying systems." — Source: [Fireside.fm]
  3. On High Agency: "As AI tools become more powerful, there's always going to be a market for high agency people who can orchestrate these tools to solve complex problems." — Source: [Madrona Podcast]
  4. On Model Competition: "Anthropic's recent gains can be attributed to their Claude 3.5 Sonnet model. Its combination of speed, cost, and output quality has won over the developer community for the time being." — Source: [Business Insider]
  5. On AI Orchestration: "The Vercel AI SDK was built to bridge the gap between large language models and rich, interactive frontend applications." — Source: [Vercel AI SDK Announcement]
  6. On Streaming AI: "Streaming responses are critical for AI applications. It changes the perceived performance from waiting for a slow API to watching a fast thought process." — Source: [LogRocket Blog]
  7. On AI as a Co-pilot: "AI isn't here to replace the frontend engineer; it is here to handle the rote scaffolding so engineers can focus on business logic and custom interactions." — Source: [LeadDev]
  8. On Deterministic Outputs: "One of the biggest challenges in Generative UI is coercing non-deterministic LLMs to consistently output valid, parsable, and safe component code." — Source: [Syntax Podcast]
  9. On the AI Ecosystem: "The landscape of AI models is shifting rapidly, which is why developers need abstractions that allow them to swap underlying providers without rewriting their UI layer." — Source: [DevShows]
  10. On AI and Design: "AI fundamentally changes the design phase. You can now explore dozens of visual directions in the time it used to take to build one wireframe." — Source: [Shapes.inc]

Part 6: On React and the Frontend Ecosystem

  1. On React's Complexity: "React is becoming a black box." — Source: [ITMagination]
  2. On React Hooks: "React was never going to be the best Hooks library. There is a gap between the mental model of React and its underlying reality compared to other reactive libraries." — Source: [Dev.to]
  3. On SSR Frameworks: "After.js was an experiment to see what would happen if Next.js and React Router had a baby, focusing on universal rendering with high flexibility." — Source: [GitHub]
  4. On Component Architecture: "Good React components should do one thing well. When you start mixing data fetching, state management, and complex UI in one file, you lose composability." — Source: [Reactiflux]
  5. On the Evolution of React: "As React introduces features like Concurrent Mode, developers must be more disciplined about side effects and render purity." — Source: [iJS Conference]
  6. On Framework Consolidation: "The ecosystem is naturally consolidating around opinionated meta-frameworks because piecing together a modern React stack from scratch is too error-prone." — Source: [PodRocket]
  7. On State Management Trends: "We are seeing a shift away from heavy global state stores toward localized state and specialized data-fetching libraries." — Source: [Syntax Podcast]
  8. On Developer Velocity in React: "The speed at which you can ship a React application is directly tied to how quickly you can trust that your changes didn't break existing features." — Source: [Vercel Blog]
  9. On the Virtual DOM: "The Virtual DOM was a brilliant abstraction, but understanding its diffing heuristics is essential for debugging performance bottlenecks in large apps." — Source: [YouTube Tech Talk]

Part 7: On Open Source and Community

  1. On Open Source Motivation: "Open source for me has always been about sharing the solutions to problems I was already being paid to solve in my agency." — Source: [JaredPalmer.com]
  2. On Maintaining Projects: "Maintaining an open-source project is heavily about expectation management and building a community that helps triage issues." — Source: [GitHub Sponsors]
  3. On Documentation: "A library is only as good as its documentation. If developers can't figure out how to use it in five minutes, they will move on." — Source: [Formik Docs]
  4. On Community Contributions: "The best PRs aren't just code; they are bug fixes accompanied by clear, reproducible test cases." — Source: [Reactiflux AMA]
  5. On Corporate Backing: "Bringing Turborepo into Vercel allowed the project to scale and integrate deeply into a broader ecosystem much faster than an indie project could." — Source: [Vercel Announcement]
  6. On API Design: "When designing an open-source API, you have to optimize for the 90% use case while leaving escape hatches for the 10% edge cases." — Source: [Dev.to]
  7. On Empathy in OSS: "You have to remember that behind every GitHub issue is a developer who is likely stressed and blocked on a deadline." — Source: [PodRocket]
  8. On Project Longevity: "A successful open-source project eventually becomes boring. Stability and predictability are features." — Source: [iJS Conference]
  9. On Collaboration: "The React community's strength lies in its willingness to share patterns and collectively push the boundaries of frontend architecture." — Source: [LeadDev]

Part 8: On Engineering Philosophy and Leadership

  1. On Distributed Teams: "Vercel's one of the fastest-moving companies in the world, but we're very distributed. Asynchronous communication is key." — Source: [Madrona Ventures]
  2. On Finance Background: "Coming from a background in finance taught me to value systemic efficiency and to view developer time as a highly quantifiable asset." — Source: [Fireside.fm]
  3. On Problem Solving: "Don't build a complex tool just to build it. Build it because the current way of doing things is fundamentally broken." — Source: [Syntax Podcast]
  4. On Product Vision: "A great developer product doesn't just solve a technical problem; it makes the developer feel powerful and productive." — Source: [YouTube Keynote]
  5. On Technical Trade-offs: "Every architectural decision is a trade-off. The job of a senior engineer is to make those trade-offs explicit and documented." — Source: [Earthly Blog]
  6. On Focus: "It is easy to get distracted by new shiny technologies. Focus on the tools that demonstrably reduce your time to ship." — Source: [LogRocket]
  7. On Shipping: "Perfectionism is the enemy of shipping. Get the first version out, gather feedback, and iterate relentlessly." — Source: [Substack]
  8. On Leading Engineering Teams: "Leadership in engineering is about removing roadblocks so your team can enter a state of flow and stay there." — Source: [DevShows]
  9. On The Future of Engineering: "The role of the software engineer is moving from writing syntax to directing systems. The logic remains, but the leverage increases." — Source: [Latent Space]