Getting started with Pagelove
Build the web you want.
Welcome to Pagelove. Thank you for coming on this journey with us, we don't take it for granted 💜
Please join our WhatsApp Group and tell us when something breaks, or if you get stuck!
What you're about to do
Four steps; setup and verification time will vary:
- Create an account
- Open Claude Desktop and install the Pagelove skill
- Get an API key and link the two
- Ask it to build an app, then verify the result
The goal is a first deployment you have checked on the intended host. Getting a URL is only one part of that process.
1) Signup
- Open the Pagelove console to create an account. If you already have an account, use Log in and follow the passkey or email-code prompts offered there.
- Follow the account-creation and verification prompts shown there.
- Continue to the console when you have finished.
Start from this console link each time. A link copied from the middle of signup can expire because it belongs to that visit. If the sign-in page expires or shows an error, reopen the console link to start a fresh sign-in flow. If you have already created an account, sign in to that account rather than creating another.
After account setup, open Hosts in the console and choose the intended host. If you need a separate test site, use New host and follow the console's prompts. Confirm the host and its public URL before publishing.
What's a host? Your live site: a URL and the space behind it where your files live. Could be one static page, could be a full app. Want somewhere to test things? Just create a second host :)
2) Verify the Pagelove integration for your installed version
The installation sequence below has not been verified on a clean installation during the November 6, 2026 documentation review. No compatible client version or protected credential-storage mechanism is established here. Confirm the current integration instructions and version before following it. If they cannot be verified, continue with the manual publishing steps; do not paste an API key into an agent conversation.
- Click on your name in the bottom left corner
- Click on settings
- Click "Plugins" on the left
- Click "Add" in the top right corner
- Select "Add marketplace"
- Click "Add from a repository"
- Enter
pagelove/pagelove-marketplace - Click "Sync" and wait while the Pagelove Marketplace loads
- Click the "+" on the Pagelove dev skill
- You'll get a confirmation popup: "Pagelove dev is installed and ready to use."
3) Get an API key and link Pagelove to your coding agent
An API key is an access credential. The service and host configuration determine its effective permissions. Keep the credential separate from the instructions describing what you want the agent to do.
- Open the console and use its current credential controls to create an API key.
- Identify the intended host and required operations, and establish the credential's actual scope from the service's configuration or documentation. Asking an agent to use one host does not make the key single-host or read-only. If scope is not exposed, leave it unverified rather than assuming a restriction.
- Configure the key only through the integration's documented credential-entry mechanism. Check where it stores the value and whether the value can enter conversations, tool arguments/output, or generated files. Do not paste it into a prompt or chat message.
- Verify the connection with an approved read-only operation on the intended host, without printing the key or authorization headers. A successful read checks that connection; it does not prove write permission or application validation.
Keep keys out of conversations, screenshots, served HTML/browser code, repositories, shell history, and logs. A configuration file is not automatically protected merely because it is local.
This page does not establish a particular secure credential mechanism for your installed agent. If its integration does not document one, leave the automated connection pending and ask Pagelove support for setup instructions without sharing the key. Use the console-upload or WebDAV steps below meanwhile. Continue with automated deployment only after its documented credential setup works.
If a real key has already been exposed in a conversation, log, repository, or public file, use the available credential-management controls or contact support to ensure it is revoked and replaced safely. Deleting the text or creating another key is not proof that the exposed credential was revoked.
If the agent requests authorization, check the integration, destination host, and requested operation against your intended task. Approve that scope; a permission prompt does not prove that the key itself is restricted.
4) Build something
After the credential setup in step 3 is verified, select an isolated test host and use harmless sample data. You can adapt this suggested prompt. Its output still needs review and checks on that host:
Build a small kanban board on Pagelove with To Do, Doing and Done columns.
Use semantic HTML with Microdata as the authoritative card source, stable
card identities, and declared fields, allowed values and bounds. Keep
local drafts and temporary controls/status outside persisted card data.
Provide labeled native controls to add cards and choose a destination
column, usable by keyboard and pointer. Make dragging optional; use the
same save path for every way of moving a card.
Use the host's supported application HTTP path and deliberate server-side
access and validation rules. Keep deployment credentials out of browser
code, published HTML, conversations and logs.
Use supported concurrency controls for each write. Preserve drafts on
refusal, conflict or unknown outcomes; reconcile uncertain writes before
resending. Distinguish pending, confirmed, refused, conflict and unknown
states without marking newer draft edits as saved by an older response.
Deploy only to the agreed test host and preserve data already there.
Report the URL, source files, save path, actual checks and remaining gaps.
List any behavior you could not verify.
Keep later tool requests within the approved scope. If a request expands it — to another host, new access, or a deletion you have not requested — review that expansion first. A command name such as curl does not by itself describe the operation's impact.
Before sharing the app, check the actual result:
- Identify the intended host, source files and card identities, application save path, release/configuration, and intended readers/editors. Record platform capabilities as unverified where they cannot be established.
- Add and move a harmless card using the native controls by keyboard and pointer. Verify that the same card's intended fields changed through an independent, permitted server read of its source or declared projection, and that unrelated data did not change. Account for the serving path's cache behavior: a reload alone can show a local or cached copy.
- Follow the first deployment checklist for actual access, validation, concurrency, interrupted saves, recovery and publishing checks. Exercise visitor operations with the intended visitor identity; an authoring upload or a request using deployment credentials does not prove application enforcement. Use the save and failure recovery example for the narrower conditional-save model, adapting it to the app's supported operations.
- Keep the checklist's deployment record with the app: reviewer, date, actual target/revision, observed result and evidence. Mark omitted checks Not applicable with a reason. Resolve any required check that failed or has not been done, or keep the affected capability unavailable before inviting people to rely on it.
A generated page and URL begin this review; confirmed persistence, access and usable editing need their own evidence. For the source, view and save boundaries behind these checks, read how an application fits together.
Very little changes in how you work, we just simplify things
Keep your existing editor and review workflow. Pagelove supplies document storage and serving services; your application defines its information, operations and access policy.
| Area | Your project | Pagelove's role |
|---|---|---|
| Version control | Review and version application definitions, templates and scripts. | Live user content also needs a recovery plan; a source checkout is not its backup. |
| Your editor | Use tools that support your chosen authoring workflow. | WebDAV presents stored resources through a filesystem-style interface. |
| Your coding agent | Choose an agent and review its output. | Use its documented integration setup and the verification steps above. |
| Publishing | Publish reviewed files and preserve existing user information. | Authoring changes live resources; verify the served result and relevant cache behavior. |
| Testing | Configure a separate host's identity, access rules and harmless test data deliberately. | A separate host gives you a target for checks before publishing changes to the intended live host. |
| Application data | Define semantic HTML/Microdata sources, identities and allowed values. | Managed document storage persists accepted changes to those sources. |
| HTTP interface | Choose supported operations and define their access and validation rules. | Document and fragment HTTP operations provide an API for reading and writing. |
| Build tooling | Use the tooling required by your assets and dependencies. | Publish its reviewed output through the supported authoring workflow. |
The folder view is an authoring interface to stored resources. A visitor's serving URL can return a composed view assembled from several sources. Identify which source an editable fragment belongs to and which supported operation saves it; the rendered page and stored source can differ.
How Pagelove works
Pagelove stores HTML documents as structured elements, attributes and text. Browser code can use the platform's document and fragment HTTP operations to read and change supported targets. Use the documented selector range or client helper when addressing a fragment; an ordinary URL fragment by itself is not that HTTP request.
Changing the browser DOM edits a local working copy. The app must deliberately send its intended change through a supported save operation and handle the result before presenting it as confirmed shared state. Follow the save and failure recovery model, including retained drafts and uncertain outcomes.
The serving path can compose pages and applies the configured authorization and application validation for the relevant operation. Microdata labels describe information; define the applicable schemas and shapes explicitly. Establish actual capabilities and rules on the target host rather than assuming a reference feature is enabled there.
WebDAV authoring has its own authentication and deliberately bypasses application schemas, constraints and handlers for whole-document and selector writes. Its successful save does not demonstrate that an application write would pass validation. Keep those privileged credentials separate from visitor access.
During release, distinguish application-owned definitions from mutable user content. Replacing a whole live document can overwrite edits made since it was read. Coordinate authoring changes and use the first deployment checklist to verify publishing and recovery.
Read how an application fits together for the complete source, view and save model.
Already have a site to deploy?
Use the same reviewed publishing scope whether you upload in the console or edit over WebDAV:
- Open the console, select the intended host and record its serving URL and the paths you intend to change. Exercise the workflow on an isolated test host with harmless data first.
- Review the files to publish. Distinguish application definitions from current user-managed content, keep recoverable copies of resources you will replace, and coordinate with other editors. A local project file may be older than the live document it would overwrite.
- If your console provides a documented upload workflow for that host, use it for the reviewed files and confirm the destination paths. Otherwise use the WebDAV workflow below. Separate file saves are not an atomic release.
- Review the reported outcomes and inspect the target before repeating a partial or uncertain upload. A lost response does not establish that nothing was saved. Check the served result through the intended visitor path and complete the first deployment checklist; a successful upload alone does not verify application access, validation or readiness.
Keep the reviewer, date, host, actual release/configuration, affected paths and verification evidence with the deployment record. Keep credentials and private content out of that record.
Prefer WebDAV?
- Obtain the actual WebDAV authoring URL for the selected host from its current details or supported setup instructions. Check the credential's actual scope as described above; choosing one mount URL does not itself restrict the credential to that host.
- Use the current documented credential controls and a compatible WebDAV client. Supply credentials through its documented protected mechanism, keeping them out of conversations, served files and logs. This page does not verify current console button names or a particular client's credential storage.
- Mount the authoring URL and use an authorized listing or read to check the intended target before applying the reviewed write set. The WebDAV mount is live: saving through the client can replace content another person or application has changed since you read it. Coordinate those edits and follow the publishing checks above.
For a forgotten password, follow the supported credential-recovery or replacement procedure. Identify the affected clients and scope before changing or retiring a shared credential, then update those clients and check their intended access. When the old credential must be retired, establish that through the supported management procedure; creating another credential or deleting a local copy does not by itself establish server-side revocation.
If setup or recovery instructions are unclear, stop at that step and ask Pagelove support for guidance without sharing the credential.
Getting help & staying in touch
We want to hear how it's going, what breaks, and what you build.
- WhatsApp for smaller, more informal conversation.
- Discord for developer discussion and to see what others are building.
- Email hello@pagelove.com any time.
- Book 1-on-1 time with James, who invented all this.
Build something, break things, tell us how it went. 💜