Overview#

This week we introduced Partials, a new play variant built for smaller, reusable pieces of software. Instead of forcing everything into a starter, template, or stack -- Partials give developers a way to publish and deploy focused units like components, sections, blocks, and other targeted code snippets.

The goal is simple: make it easier to reuse the valuable middle layer of software that sits between a full app and a single copy-paste snippet.

What's New#

• Added Partials as a new way to package reusable code
• Added support for deploying a Partial on top of a larger template project
• Added support for file-level and directory-level Partials
• Added CLI support through playbooks add <uuid>
• Added a cleaner path from discovery to install for smaller building blocks

A Smaller Unit of Reuse#

Partials can be as small as a single file or as large as a directory of related files. That makes them a better fit for real-world building blocks that do not need to stand on their own as a full project.

This opens up a more practical publishing model for things like:

• UI components
• page sections
• feature blocks
• focused patterns that belong inside a larger codebase

Designed to Layer on Top#

Partials are designed to deploy onto another play, typically a starter or template that already contains the broader application structure. That means you can start with the plumbing you need, then layer in focused functionality one piece at a time.

They also support the same broader deployment story as other plays, including demo configuration, private files, credentials, and install instructions where needed.

CLI Support with playbooks add#

To make Partials more useful in day-to-day workflows, we also added the playbooks add <uuid> command to the CLI. That command is designed to pull a play into your local project, place it in the destination you choose, and run the install commands needed to get it working.

The result is a much cleaner path from:

• finding a Partial
• adding it to a project
• installing what it needs
• continuing work locally

Best Fit#

Partials work best when paired with a larger base project. A good workflow is to start with a starter or template that gives you the right framework and infrastructure, then layer Partials on top as needed.

That keeps the overall setup flexible while still letting each reusable piece stay focused and composable.

That's all for now#

Partials are an important step toward making Playbooks useful across more of the software lifecycle, especially the in-between layer where developers are often reusing patterns rather than entire apps. We're excited to keep building around this model and make the path from discovery to implementation even smoother.