What’s new in Playcode

Closing every panel in the editor used to leave a blank screen with no visible way back - it could look like your project was gone. It never was: your work is always saved.

Now the editor keeps its header with the project menu at all times, and an empty workspace shows the AI prompt plus one-click buttons to reopen Preview, AI Chat, and the other panels. Asking the AI from there opens the chat with the answer. And if a saved project somehow ends up with no panels at all, it now opens with the standard layout instead of a blank screen.

Ask for a mobile app - or add one to a project you already have - and the agent builds it alongside your site and backend, in the same project.

• One project, three surfaces. The mobile app (React Native + Expo)

lives next to your frontend and your NestJS backend and talks to the same API and database. A mobile app that arrives with a real backend, its own data, a domain and email is the whole product, not a demo shell.

• See it in the browser first. The app renders inside the normal

Playcode preview while the agent works, so you watch screens appear without touching your phone.

• Then hold it in your hand. Scan the QR code the assistant prints in

chat and the same app opens on your real phone through Expo Go, live against your project's backend.

Store binaries and app-store submission are a separate, upcoming step - what ships today is building, previewing, and running your app on a real device.

Your project's address no longer requires a detour through a registrar.

• Search, buy, attached. Look up a name, pay with your card, and the

domain is registered to you and connected to your project - DNS records, the www variant, and the certificate handled for you.

• A guided flow that tells the truth. Every step of the purchase shows

its real state - reserved, registered, connecting, live - so you are never left staring at a spinner wondering if your money did anything.

• Your domain stays yours. It is a normal registration in your name;

nothing locks it to us.

The publish dialog could not be scrolled on a phone, which on small screens put the confirm button out of reach. The dialog body now scrolls properly, so you can publish a project from your phone end to end.

Speaking your idea on the home screen asked the wrong wallet whether you were allowed to. If you were working inside a team workspace, the microphone checked your personal plan and credits instead of the team's - so a team with an active subscription and credits to spare could still be told it needed to subscribe.

Voice now prices the same workspace everything else does: the one you have selected, which is the one a new project is created in and the one that pays for the work. Typing was never affected.

On very long builds the agent periodically folds older conversation history into a compact brief to stay fast. That fold used to be lossy: the agent could forget its instructions, lose its place, and re-read files it had just read. The whole handoff was rebuilt:

• The agent now writes its own handoff note. Instead of an outside

summary, the model working on your project writes a structured continuation brief for itself - what it was doing, what it decided, what comes next, in its own words.

• Task instructions can no longer be lost. A background task's original

instructions survive every handoff word-for-word.

• No more re-reading loops. The brief carries the exact code regions the

next step needs, pre-loaded - resuming costs zero extra reads instead of re-opening file after file.

• A stuck loop breaks itself. If context refills right after a fold, the

agent gets more room instead of folding again and again.

• A heads-up before the fold. The agent is warned as the handoff

approaches, so it finishes the step it is on and writes things down first.

Ask for something big - a storefront, an admin panel, order emails - and the agent now breaks it into parts you can follow, instead of leaving you to read a stream of technical steps.

• A plan card in the chat. The parts of your order in your own words,

each one pending, building, or done. On full-stack apps, a part only turns done after the server checks that its page actually loads - and every finished part carries an Open button with the real address, so "the admin panel is ready" is a click, not a path to guess.

• One line while it works. During a build, a quiet line above the

message box shows which part is in progress and for how long - real elapsed time, not a guess.

• The plan opens as its own page. Click it to read the full plan,

nicely rendered with diagrams, without leaving the chat. When the agent updates the plan, you see what changed - changed sections are marked, and a history lets you read any earlier version. Every plan change is a real commit in your project's git history.

• The preview stops playing dead. While the agent rebuilds your app,

the preview keeps the last good page dimmed under one line - "Rebuilding this page - it comes back by itself" - instead of flashing white. A new health check catches blank pages the old green light missed. When nothing is running, real errors still show as errors.

• The agent answers in your language. Switching the app language now

reliably carries into the agent's replies, plan titles, and progress notes.

• Bring your own instructions and skills. A project's AGENTS.md is

now read automatically by every agent working on it - same rules as other AI coding tools, whole file, no silent truncation - and projects can carry their own skills in .agents/skills/, listed and loadable like built-ins.

On long builds the agent periodically compacts older conversation history to stay fast. Until now it compacted early enough that big tasks - many files, long sessions - could lose track of files it had just read and re-read them.

• The default Context level is now High (was Medium). On models with large

context windows the agent keeps roughly 2.5x more of the conversation before compacting, so long builds stay coherent instead of looping over the same files.

• No extra confirmation for the default. The one-tap cost acknowledgment

now appears only when you raise Context above High (Extra High or Max).

• Your explicit choice is untouched. If you set Medium (or any level)

yourself, that choice stays exactly as you set it.

You can still change Context per chat in the build-quality dialog, or set your own default in Settings → You → AI defaults.

When your app emails an address that has not confirmed it wants mail yet, that message is Held - stored safely, waiting on a verification. Until today, a held message looked just like normal captured mail, and it was easy to miss that real messages were waiting on you. That is fixed, end to end:

• A new Held status. Held messages show an amber Held chip with the exact reason on the row - clearly separate from mail that is simply captured by design.
• A standing notice in the editor. While anything is held, the panel shows "N messages waiting on you" with a direct door to Settings > Email.
• An email to you. The first time a message is held for an address, the project owner gets an email naming the address - so a contact form filling up overnight can no longer wait silently. Repeats fold into at most one summary a day.
• Deliver held mail in one click. Once the address verifies, Settings shows how many messages were held and a Deliver held button. Nothing ever sends without you.

Two more changes in the same area:

• The Mailbox panel is now called Emails - a clearer name for what it is: every email your app sent, with its delivery status. Playcode Email sends mail; it does not receive it.
• A new help page, What emails can your app send, explains the transactional-only sending policy in plain language.

When the assistant starts a long job - a build, an app-store submission, a big install - the chat now stays yours.

• You can always talk. A message you send while a job runs reaches the

assistant immediately, mid-work, instead of waiting in silence until the job ends.

• Stop means stop. Pressing Stop lands in about two seconds, even during a

long wait - and the assistant stays quiet afterwards until you speak.

• Finished jobs report back on their own. When a background job completes,

a small note appears in the chat and the assistant picks the result up and continues - even if it had already handed the chat back to you. A running job can no longer be forgotten.

• One question, one answer. A message sent at just the wrong moment no

longer risks two competing replies.

When something has to reach your phone - opening your app in Expo Go, checking a preview on a real device - the assistant now draws a QR code in the chat instead of asking you to type a long address across two screens.

• The address stays printed under the code as selectable text, so on a desktop

you can still copy it in one click.

• The code carries the Playcode mark in the middle, and it is rendered to be

scannable rather than decorative: it sizes itself to the address it holds, and in a column too narrow to scan from it steps aside and leaves you the text.

• It works the same in dark and light themes.

Only for addresses that genuinely have to cross to another device. A link you can simply tap stays a link.

If you were signed in but arrived on a device or browser Playcode had never loaded before - a new laptop, a cleared browser, a private window - opening a template link directly (/javascript-template and friends) could leave you staring at an empty editor: no files, no preview, no menu. Reloading did not help.

The editor was starting before your account finished arriving from the server, and then quietly gave up. Two things changed:

• The editor no longer waits on that data to build your project, so a first

visit on a new device opens the same way a returning one does.

• If an open genuinely fails, you now get a clear message with a Retry button

instead of a blank page.

When you upgrade to Max, every project you already have now moves to the larger Max machines automatically - 8 CPU · 16 GB in the editor and bigger production machines with a 200 GB disk - not only the projects you create after upgrading.

• Projects that are asleep pick up the new hardware silently and wake up on

it the next time you open them.

• An editor you are actively using switches on its next idle pause, usually

within minutes.

• Published production apps pause briefly - usually seconds, at most a couple

of minutes - while they move to a bigger machine.

And if you ever move back to Pro: CPU and RAM return to Pro sizes, but any disk space you grew into stays yours. We never shrink your disk.

We reshaped the paid plans around one idea: a dollar buys the same 4 AI credits everywhere, and the plans differ in how much you get - not in what a credit costs.

• Pro is now one simple plan. $25/month, 100 credits, 3 full-stack cloud

apps, custom domains. No size picker - a heavy month is covered by top-ups.

• Meet Max (formerly Business). For people who need more of everything:

5 cloud apps, larger VMs (8 CPU · 16 GB editor), 1 TB/month bandwidth - and now with double the credits at the same prices. $100/month includes 400 credits, $200 includes 800, $400 includes 1,600, and new sizes reach $2,500/month with 10,000 credits.

• Top-ups are one rate for everyone. $1 = 4 credits on every plan, with

the same volume bonuses (+5% at $50, +10% at $100, +20% at $200).

Existing subscribers keep their current plan and price; Business subscribers get the doubled credits automatically from their next renewal.

Connecting a custom domain to a Cloud app now explains itself better - especially for root domains.

• Squarespace DNS is now recognized. If your domain runs on Squarespace

nameservers, the wizard shows the exact ALIAS record their panel expects.

• The wizard names your DNS provider. When a root domain can't point at

Playcode, the wizard now tells you which DNS service it detected and which nameservers prove it - no more guessing whether the check is right. This especially helps domains bought at Google Domains and moved to Squarespace, which often still run on Google's nameservers behind the scenes.

• Unknown providers are never a dead end. If we can't identify your DNS

host, the wizard now shows the ALIAS record to try instead of blocking you - and still recommends the www address that works everywhere.

Browser projects now have Checkpoints - restore points you can save at any moment and return to instantly.

• Save a restore point. Open the project menu and choose **Checkpoint

history, then New checkpoint**. It captures all your files exactly as they are - instantly, without using any credits.

• Name your checkpoints. Rename any checkpoint so "Before the redesign"

is easier to find than a date.

• Restore instantly - and undo it. Restoring puts every file back the way

it was. Playcode saves a safety checkpoint of your current state first, so a restore is never a one-way door. The page does not reload, and your chats stay exactly where they are.

• Publish keeps you covered. Every publish automatically saves a

checkpoint of what went live, so you can always get back to a published state.

You can keep up to 20 checkpoints per project. At the limit, Playcode asks before making room by deleting the oldest one.

Want to explore two directions side by side? Use Duplicate project - the copy gets its own files, chats, and published site.

Email on Playcode Cloud grows up: on paid plans, your app's emails are now really delivered - not just captured in the Mailbox.

• Deliver to verified recipients. Your own address works instantly (you

verified it when you signed up), and your team's addresses too. Add anyone else in Settings > Email - they get a verification link, and once they click it your app can reach their real inbox.

• Honest status on every message. Mailbox messages now show their real

fate: Sending, Delivered, Bounced, or Marked as spam - with the reason, so debugging "the email didn't arrive" takes one glance instead of guesswork.

• New apps send from day one. A fresh full-stack app now emails a

welcome message to its very first registered user - so you see your mail pipeline working before writing a single line of email code.

• Fair pricing. Emails to yourself and your team are always free.

Beyond your plan's monthly allowance, delivery is pay-as-you-go with credits - priced in line with the leading email APIs.

Free projects keep the full capture experience: every email lands in the Mailbox, rendered with working links, ready to test end to end.

Playcode can now build presentations, and it asks one question first: do you want a link you open in the browser and present fullscreen, or a .pptx file you download and edit? They are different things, so it settles that before writing a single slide.

The .pptx is a real one. Actual text boxes you can click and retype, real tables, real speaker notes, charts that carry their own data sheet. It opens in PowerPoint, Keynote and Google Slides, and Cyrillic, Japanese and emoji come out exactly as they went in. This is not a picture of a slide wrapped in a PowerPoint file, which is what most "export to PPTX" buttons hand you.

The more interesting version is a deck generator. Describe the presentation you rebuild every cycle - the monthly client report, the one-pager per prospect, the board update - and Playcode builds you an app that produces it. Your spreadsheet, database or CRM export goes in; finished decks come out, one or two hundred of them, on brand every time because the brand is written into the code. Next month you press the button instead of rebuilding the deck.

A few things worth knowing:

• Generating files needs a full-stack app, since a static site has nowhere to write one. Playcode will offer to set that up.
• Ask for both and you get both from one source: a browser deck to present from, plus a download. Change a slide once and both update.
• Slides use fonts that exist on the machine opening them, so nothing reflows into a substitute when you send the file to a client.

Playcode can now make audio. Ask for it in plain words and you get a file, hosted and ready to use in your project:

• Music - a background bed at an exact length. Ask for eighteen seconds and it ends on the eighteenth second, which is most of why a video reads as finished rather than assembled.
• Sound effects - short one-shots. A click, a coin, a whoosh, a notification.
• Voiceover - narration read aloud, for a walkthrough, a tutorial or an explainer.

It works in any project. A browser game can have its own soundtrack and its own effects without becoming a full-stack app, because the audio is generated on Playcode's side and your project simply receives the finished file.

Everything comes back already levelled to the loudness social platforms and browsers expect, so a clip does not arrive twice as quiet as everything else on the page and need fixing by hand.

Audio uses credits from your balance, priced by what each piece actually costs to make - so a one-second sound effect costs about what a one-second sound effect should, and you are not buying a bundle to get one noise.

On iPhone, tapping certain inputs - the answer boxes when the AI asks you a question, search fields, rename boxes - zoomed the page in. That part is normal iOS behavior for small text fields. What was not normal is that you could not get back: pinching to zoom out did nothing almost everywhere, so the app stayed magnified and unusable until you reloaded.

Two things were wrong, and both are fixed.

• Pinch-to-zoom works again across the app. The chat transcript, the message box, and every editor panel were opting out of the browser's zoom gesture - only the top bar still responded to a pinch. They now allow it, while keeping the scrolling and drag behavior they were reaching for.
• Fields no longer trigger the zoom in the first place. Text you type into is now sized so iOS leaves the page alone on focus, on phones and tablets. It is also simply easier to read.

Nothing changes on desktop.

Full-stack apps on Playcode Cloud now send email out of the box - no provider signup, no API token, no DNS setup.

• Zero configuration. Password resets, verification emails, order

notifications: your app's email code just works. Playcode provisions the credentials automatically when your app is created.

• The Mailbox panel. Every email your app sends appears in the editor's

new Mailbox panel within seconds - rendered exactly as a recipient would see it, with working links. Trigger a password reset, click the link in the captured email, and complete the flow end to end without leaving Playcode.

• Safe by default. New apps run in capture mode: emails are stored and

shown to you, never delivered to real inboxes - so you can build and test freely. Real delivery to your users is coming next.

• API keys, done properly. The new Settings > API keys page manages

named keys with per-key permissions (send-only or full access), shown once at creation and revocable individually - and Settings > Email shows your sending mode and usage at a glance. A stuck loop that sends the same email over and over is paused automatically; one click resumes it.

Signing up is now one continuous flow instead of a series of popups.

• One setup journey. Answer a couple of quick questions right where you

signed up - no second dialog appearing later, no design jumps.

• Team setups land right. If you choose With my team, your company

workspace is created during setup and your first project is created inside it - together with your welcome credits. Working solo? Everything stays neatly in your personal workspace.

• Your work survives sign-in. Building something before signing up?

Your edits and drafts now survive signing in with GitHub or Microsoft, and your project is saved to your new account exactly as you left it.

Clicking Logout could quietly do nothing: the menu closed, no error appeared, and you were still signed in. It happened when Playcode was open in more than one tab - the sign-out waited on a local data cleanup that a second tab was holding, and then waited forever.

Sign-out no longer waits for anything. Your session ends the moment you click Logout, and the local cleanup happens afterwards where it cannot get in the way.

Two related gaps closed at the same time:

• Every tab. Logging out in one tab now ends the session in your other Playcode tabs too, instead of leaving them signed in with a session that no longer exists. A tab holding unsaved work stays put rather than reloading over it.
• Only your own data. Signing out used to try to clear the cached data of every account that had used the browser. It now clears only yours, so signing out of one account no longer disturbs another on a shared computer.

"How do I share projects with my team?" is the question we get most, so the Help Center now answers all of it - no support chat required:

• How to share a project - invite people by email

with Viewer, Editor, or Admin roles, manage the Access list, and use the public link. Fully rewritten for the current Share tab.

• Workspaces and teams - the difference

between your Personal workspace and a team workspace, inviting members, and granting access to a whole team at once.

• Roles and permissions - the full

reference: what each role can do in projects and workspaces, how overlapping access combines, and how invitations work.

• Move a project to another workspace -

bring existing projects into your new team workspace. Chats, data, and history travel with them; nothing needs to be recreated.

The Learn about sharing link in the editor's Share tab now lands on the rewritten guide.

If you work in a team workspace, the Home screen previously checked your personal credit balance - so it could warn "You're out of credits" even though your team workspace had plenty. Fixed:

• The right wallet. Home's composer now shows the credits of the

workspace your new project will be created in - the same number the workspace menu shows.

• The right button. "Top up" from Home adds credits to that workspace,

and team members without billing access see a note to ask a workspace admin instead of a checkout they can't complete.

• Warnings stay honest. Dismissing a low-credit warning in one

workspace no longer hides a real warning in another.

Every pending invitation in the Share popup now has a Copy invite link button. It copies the exact accept link from the invitation email, so you can send it over Slack, WhatsApp, or any other channel.

This helps when an invitation email gets caught by a spam filter or a strict corporate mail gateway: instead of re-sending the email and hoping, copy the link and deliver it yourself. The link is only visible to people who manage the invitation - the project owner and workspace admins.

Available in both the browser editor and the Cloud editor, on desktop and mobile.

When we ship a new build, Playcode offers to reload so you get it. That reload used to happen immediately - and if you had a browser project you hadn't saved yet, it went with the page.

Now the reload saves first. If you're signed in, your project is written to your account before anything else happens, and edits still syncing get a moment to land. If it can't be saved - you're signed out, for instance - Playcode asks before reloading instead of deciding for you.

Two related gaps closed at the same time:

• Other tabs. Reloading in one tab used to reload the rest instantly. A tab holding unsaved work now keeps it and waits for you.
• Closing or refreshing the page. The browser's "leave site?" warning now appears for an unsaved project on any exit, not only when moving between pages inside Playcode.

Projects created with the AI builder and Cloud projects were never affected - those save to your account continuously.

Picking a plan on the pricing page while signed out now opens a one-click sign-in right there - your chosen plan is saved server-side and checkout continues automatically the moment you're in. No more dead ends for visitors who weren't signed in, and subscriptions always land on your own account.

We also fixed a frustrating loss: if you typed a prompt and signed up mid-send, some paths could drop it. The prompt now survives sign-in everywhere - including sign-ins that reload the page - and lands back in your composer or sends as intended.

Payment flows no longer show the signup survey; it can wait until after you're building.

If your first publish failed, the project could be left unable to publish at all: pressing Publish again would stop immediately, and the project card kept showing "Publishing..." forever. That is fixed. Every publish attempt now ends in a state you can act on, so you can always fix your app and publish again.

When a publish fails its health check, we also now show you your app's own startup log with the error. That is the part that actually explains the failure: your code deploys fine, but the app's server does not come up, so the published URL never responds. Previously that log was not kept, and the deploy log looked clean because the deploy itself had succeeded.

Two related improvements: the publish progress window no longer blocks the editor, so you can keep working while a publish runs or close it if something goes wrong. And if a publish is interrupted and left behind, we now clean it up automatically instead of leaving the project stuck.

If a health check keeps failing, check that your app listens on the path set as healthcheck.path in playcode.yml, or point it at a path your app actually serves.

New subscriptions now start with monthly billing selected, so the first payment matches the monthly price shown in Playcode. Annual billing and its savings remain one click away.

Stripe Checkout also no longer requires everyone to fill in a full billing address. It asks for address details only when they are needed for the selected payment method or tax rules, while the optional business-purchase and tax-ID fields remain available.

The upgrade summary now also names Claude Opus 4.8 correctly as the default Quality model.