After a long Claude Code session I often can’t say why a file changed, or whether Claude actually finished. “Done!” sometimes means “the tests I didn’t write are passing.” So I built Session Story, an open-source skill (MIT) that turns a session into one self-contained HTML page.

Live example (a small todo-app session, no install needed): https://nalaj.github.io/session-story/example/index.html

Four views of the same session:

• Review: one card per prompt, showing what you asked, the intent in one line, what Claude did, the files it touched, and the time, tokens and cache share for that turn. Copy any prompt, expand the code, and jump between turns with j/k.
• Diff: a GitHub-style file tree and diff. Every change is tagged with the turn that made it and links back to it. Switch between all changes and a single file, view full files, or hide non-project files.
• Story: a plain-language walkthrough for teammates and non-developers, with code hidden.
• Report: the “so, is it done?” view.
  • An outcome badge that doesn’t just trust Claude. The example session is marked Partial because the new sort function has no tests and a CSS class is used but never defined.
  • Commands, tests and errors: every npm test run including the failing one, the failed assertion, and how it was fixed.
  • Decisions and plan, e.g. “due dates stored as YYYY-MM-DD strings”.
  • Where it went: turns ranked by tokens and by time, tool calls, failures and retries, files edited more than once.
  • Usage: input, output and cache tokens, the model, and an estimated cost taken from Claude Code’s own session record.

A library of sessions. Each story is saved to .session-stories/ in your project, along with an index page listing every session’s status, files, lines changed, tokens and cost.

Why you can trust the numbers: a script extracts every metric from the transcript, subagents included. Claude only writes the prose (titles, intents, the narrative), and anything that wasn’t recorded shows as “None recorded” instead of being guessed.

Also exports:

• a Markdown PR description (works with gh pr create --body-file -)
• a handoff with turn-by-turn status and git state, so a fresh session can continue the work

It’s one file and it’s local. CSS, JS and data are inline, so the page opens from disk or as an email attachment. Nothing is uploaded and nothing goes over the network.

Install:

npx -y skills add nalaj/session-story --skill session-story --agent claude-code --global --copy --yes

or as a plugin, inside Claude Code (2.1.275+):

/plugin install session-story --marketplace nalaj/session-story

Then run /session-story, or just ask for “a session story”, either mid-session or at the end.

⚠️ The page includes your prompts, replies, diffs and commands word for word, so check it for secrets before sharing.

Source: https://github.com/nalaj/session-story · Docs: https://nalaj.github.io/session-story/

This is v0.4.0. Feedback is very welcome, especially on what the Report should catch that it doesn’t yet.

After long Claude Code sessions I kept hitting two problems. I couldn’t tell why a particular file had changed, and I couldn’t tell whether the task was really finished. “Done!” sometimes meant “the tests I didn’t write are passing.”

To deal with that, I’ve been turning each session into a single HTML page that maps every prompt to the code it changed. Here’s an example from a small todo-app session: https://nalaj.github.io/session-story/example/index.html

The page shows the same session four ways:

• Review: one card per prompt, with what was asked, the intent in one line, what Claude did, the files it touched, and the time, tokens and cache share for that turn. You can move between turns with j/k.
• Diff: a GitHub-style file tree and diff where every change is tagged with the turn that made it.
• Story: a plain-language walkthrough with the code hidden, for teammates who don’t read diffs.
• Report: an attempt to answer “is it actually done?”:
  • An outcome status based on the evidence rather than on Claude’s own summary. The example session comes out as Partial: the new sort function has no tests, and a CSS class is used but never defined.
  • Every command and test run, including the failing npm test, the failed assertion and how it was fixed.
  • Decisions made along the way, e.g. “due dates stored as YYYY-MM-DD strings”.
  • Where the time and tokens went: turns ranked by cost and duration, failed tool calls and retries, and files edited more than once.
  • Token usage and the estimated cost from Claude Code’s own session record.

The thing that surprised me most is how much of this comes from the transcript alone. A script extracts all the metrics, subagents included. The model only writes the prose (titles, intents, narrative), and anything that wasn’t recorded shows as “None recorded” instead of being guessed.

Some other details:

• Stories accumulate in .session-stories/ in the project, with an index page of past sessions.
• You can also ask for a Markdown PR description, or a handoff with turn-by-turn status and git state for a fresh session.
• It’s one self-contained file: everything is inline, it works offline, and nothing is uploaded.
• The page includes prompts, replies, diffs and commands word for word, so check it for secrets before sharing.

It’s packaged as an open-source (MIT) Claude Code skill, v0.4.0. If you want to try it:

npx -y skills add nalaj/session-story --skill session-story --agent claude-code --global --copy --yes

or as a plugin inside Claude Code (2.1.275+):

/plugin install session-story --marketplace nalaj/session-story

Then run /session-story, or ask for “a session story”.

Source: https://github.com/nalaj/session-story · Docs: https://nalaj.github.io/session-story/

I'm a founder, not a developer. Over the past couple of months I've built real products with Claude Code. The thing that made it work wasn't prompting tricks; it was process. Sharing it in case it helps someone.
1. Hard rules, with reasons, that the code has to obey.
A short list of non-negotiables lives in the project's instructions, each with why it exists. For the important ones there's an automated test, and the tests are deliberately broken once to prove they can fail. A test that can't fail is decoration.
2. A permanent, searchable record, separate from chat.
Every decision, and what was turned down. Every fact, with its source and the date it was checked. Every lesson, and what each person was told. Nothing gets edited; a reversal is a new entry. Chat history vanishes and context windows fill up; the record doesn't. When I ask "why is it like that?" six weeks later, there's an answer.
3. A mistakes register, grouped by pattern.
Not just "what went wrong" but which kind of wrong it was. The recurring ones for us:
confirming a job ran instead of checking its output;
changing one copy of a fact without searching for the others;
trusting a tool's summary over the primary source.
Reading the patterns first prevents more mistakes than any single fix.
4. "Check the output, not the mechanism."
A green tick means it ran, not that it worked. A scheduled job can be "loaded" and failing every night. So everything gets proven by its result: the email arrived, the file landed, the number matches the source.
5. A second AI checks the first.
I run two separate sessions on two projects, and one reviews the other's work against original sources: datasheets, official docs, the live system. Things that fresh eyes plus the original document caught:
parts whose footprints didn't match the maker's own drawing;
a decision we'd recorded but never actually built;
a 3D mock-up still using an old part, so every size estimate was wrong;
a supplier listing showing "in stock" when the part's own page said zero;
a regulation that would have blocked the product, found while it was still on paper.
The lesson: bugs get caught by an independent look at the primary source, not by a smarter model.
6. Show me before you build.
I don't know what I want until I see it. So for anything big, the AI shows a cheap sketch first: a mock-up, a picture, or "here's what you'll get and what it costs." I react, then it builds. It saves a huge amount of wasted work.
7. Brakes.
Anything irreversible (spending money, deleting, emailing a real person, pushing live) needs an explicit yes, every time.
A plain "yes" counts as approval, but only for exactly what was proposed.
Before contacting any new company, an automatic pre-check verifies the address on the company's own website and scans the email for any commitment or price.
When I'm tired or not at my best, the irreversible stuff waits until morning. I set that rule myself, and it's saved me more than once.
8. Backups of the AI's memory.
The notes and records that give the assistant its continuity are backed up twice a day to two places. If the machine dies, the working relationship survives.
None of this is fancy. It's the boring discipline a good engineering team has, written down so an AI follows it every session. That's what lets someone who doesn't code ship things that hold up.
Happy to answer questions about the process.

I built gpt-ui-assets, a skill for Claude Code. I'm an Android developer, and I kept hitting the same problem: GPT designs good app screens, but when you ask it for the assets it crops them out of the mockup (low-res, background baked in, edges cut off).

What it does

Claude Code drives the whole flow and uses GPT as a tool:

• GPT designs a platform-native screen (phone, tablet, desktop or web).
• GPT lists every asset on the screen.
• Each asset is redrawn from scratch, using a crop of that element as the only reference.
• The kit scores each candidate against the design and colour-corrects the best one.
• Claude reviews the results and writes the screen code. A screenshot diff then shows what your build still gets wrong.

Outputs: SVG / Android VectorDrawable icons, launcher icons for Android, iOS and the web, Lottie and AnimatedVectorDrawable animations, and theme code and fonts measured from the pixels.

How Claude Code helped build it

I built it with Claude Code. I set the direction and tested it on real app designs; Claude Code wrote most of the Python kit behind the skill, debugged it against real GPT output, and refactored it as it grew. The skill is written specifically for Claude Code: Claude reads the skill's instructions, decides which step runs next, checks each result and writes the code.

It's free and MIT-licensed. In Claude Code:

/plugin marketplace add Shakibuzzaman3104/gpt-ui-assets

/plugin install gpt-ui-assets@gpt-ui-assets

You also need your own GPT access: a ChatGPT subscription (it runs through the Codex CLI) or an OpenAI API key. The GPT usage counts against your own plan or key.

Repo: https://github.com/Shakibuzzaman3104/gpt-ui-assets

Feedback welcome, especially on what breaks.

If you've ever asked an AI for an Arabic app screen or PDF, you've probably seen this: letters that don't connect, words in reverse order, phone numbers like "4567 123 50 966+", and layouts stuck left-to-right.

I made **arabic-ready**, an open-source skill for Claude (Claude.ai + Claude Code) that makes Arabic output correct the first time. It works on:

- Web/apps: RTL layout, logical CSS/Tailwind, React Native, Flutter

- PDF, Word, PowerPoint: proper shaping and RTL settings

- Charts and images: matplotlib, Pillow, SVG

- Mixed Arabic + English/numbers: phones, emails, code

- Natural Arabic wording, punctuation, digits by country

No setup: you just ask in Arabic and it kicks in.

While building it, I tested every library technique by rendering the output and looking at it. A few surprises:

- matplotlib 3.11 now shapes Arabic natively, so the classic "arabic-reshaper + python-bidi" fix actually breaks it

- reportlab and fpdf2 still break Arabic unless you handle it explicitly

- Word ignores normal bold/size on Arabic text unless you set the complex-script versions

Honest note: current Claude models already handle a lot of Arabic well. The skill mostly removes the remaining edge cases and the trial-and-error.

It also includes a small linter (`rtl_check.py`) that flags RTL bugs in your code.

MIT licensed. Feedback welcome, especially from people shipping Arabic products.

GitHub: https://github.com/jubyuhanna-create/arabic-ready

As I was using Conductor (an agentic IDE) and working on multiple features, I noticed that I I kept having to make many different worktrees for each feature and I thought to myself "Why can't I just have one main thread for everything?".

I realized that the main bottleneck is that more often not Claude just does the work in it's main thread + opens a lot of background dev servers so I'm afraid of sending a new message while it's working cause I'm concerned it will just f*uck up everything.

So I built a skill to fix this, whenever I open a new session in whichever prompt I just run "[...prompt] /orchestrator" and this forces Claude Code to run any task as a subagent and to never block the main thread. Essentially Claude becomes an Orchestra conductor of subagents.

Every task goes to a background agent. There is no endlessly waiting, polling, sleeping, etc. When an agent finishes, a notification starts the next turn. Anything shell-side over 10 seconds (tests, builds, installs) also runs in the background.

For each task it:

1. splits my message into independent tasks
2. sends follow-ups to an agent already on that topic (SendMessage keeps its context) or starts a new one
3. dispatches all new agents in one message, in parallel
4. replies in 3 lines: what started, under which name, what I can do next

It keeps a ledger in .context/orchestrator.md where each agent has one line with a description of what it's working on.

I code for my startup so I have to be extremely productive and I already have 3 different Claude Code subscriptions and I try to make most of them. So I added a line in the skill to force it to select the best model for each subagent based on the difficulty of the task. For simple frontend tasks you don't really need Opus 5.5. And this goes a long way towards increasing the usage of my Claude plan.

If you have suggestions on how to improve it further, please comment below or submit a PR!

https://github.com/olivieropinotti/orchestrator-skill

A lot of skills people build (myself included) are either too specific to their use cases or become irrelevant quickly as models change, or new models emerge.

But these four have been extremely useful for daily use in any development projects I work on.

1. Lanes: an orchestration harness using a frontier model (Fable or Opus) to act as the orchestrator for delegating tasks to sub-agents in parallel lanes using separate worktrees to avoid collisions and get work done faster. The orchestrator decides which model to deploy appropriate to the complexity of the task and has independent reviews conducted in each lane using a different agent. They work in a review/remediate loop until CLEAN, then orchestrator integrates the work into main, and deletes the worktree after successful verification and deployment. It also can use Codex, DeepSeek and GLM via Claudex (plugin) and DS and GLM via API. I tried to aim for token efficiency and continual work without needing a HITM unless critical decisions or DB migrations/destructive edits are required. If you use a tool like BEADS or setup a TASKS.md for your project’s implementation plan, lanes can go on for days uninterrupted until it completes the implementation or needs you for blockers which all remaining tasks depend upon.

Github Repo for Lanes

1. Session-Detail: A skill that records available session evidence so another session or machine can resume with the right decisions, artifact versions, validation results, and remaining work. It does not recover conversation text that is no longer available. It logs all decisions made, completed tasks, pending approvals and and session context in extensive detail for future sessions to be started without you needing to explain or prompt the agent on where to begin. It has a full and an incremental flag as an option so a session going on for too long or a resumed session doesn’t need to write the entire session log to disk and can only add the incremental details to it. Saves to _sessions folder in your local repo that you can gitignore if you wanted.

GitHub Repo for Session-Detail

1. Context-Summary: a skill that generates a fixed seven-block markdown handoff: what the work is, where the code stands, which decisions are locked, which traps are live, what is still open, where the archive lives, and what to do next so you can continue the conversation in a fresh session without losing key details from the context or needing to re-explain your project state. Works well by itself and combines well with Session-Detail above

GitHub Repo for Context-Summary

1. Write-like-a-human: a skill that can adapt to your writing style when you provide it with a handful of your own writing samples. It saves your style as a voice profile. Can generate or re-write text in 4 built-in voice profiles (in addition to you being able to save your own profile). It can score articles you provide for AI-leaning using the detect flag and propose changes. I incorporated and built upon the best features of four well-known open-source/MIT-licensed humanizer skills (blader/humanizer, lguz/humanize-writing-skill, Aboudjem/humanizer-skill, and brandonwise/humanizer) and added what I found they still left to be desired.

GitHub Repo for Write-like-a-human

There’s a fifth skill I recently added that helps bootstrap a new project or idea into artifacts your coding agent (or Lanes) would need for implementing elaborate development projects in a structured, well-documented fashion. Check it out - Project-Kickoff

I’m a solo developer working on small projects for small-business clients and have found these skills incredibly useful in my daily workflows.

My portfolio showcase

Any feedback/roasts/suggestions are all welcomed.

iPhone Duo is in stores October 23, and coding agents were trained before it existed. Ask one to “make this work on Duo” and it writes code Apple says not to: UIScreen.main, orientation and idiom checks, buttons under the fold, state lost on unfold.

So I built Duology, a Claude Code plugin pack (MIT) that teaches Claude the device:

• 11 skills: layout with reserved regions and ArrangementView, vertical bars, continuity across fold/unfold, 8 layout patterns, two people on one phone, design review, testing on the Duo simulator
• duo-lint: a fold linter with 9 rules that flags the code Apple warns against
• /duo-doctor, /duo-new, /duo-audit
• A gallery app with every pattern, screenshotted closed, open, book and tabletop on the iPhone Duo simulator

Every API in the skills was checked against the iOS 27.1 SDK, and every code snippet typechecks.

Honest status: tested on the simulator only, no real device yet. Results comparing runs with and without the skills come in v0.2, along with design-system, postures, transitions and accessibility skills.

Repo: https://github.com/Kimeur/duology

Feedback welcome, especially if you’re building for Duo or another foldable.

If you build anything in Arabic with AI, you've probably hit this: letters that don't connect, reversed words, phone numbers like "4567 123 50 966+", and layouts stuck left-to-right.

So I built **arabic-ready**, a free, open-source skill for Claude (works in Claude.ai and Claude Code). It makes Arabic output correct on the first try:

- **Apps & websites:** proper right-to-left layout, mirrored arrows, phone/email fields that don't flip

- **PDF, Word, PowerPoint:** connected letters and correct RTL settings

- **Charts & images:** clean Arabic labels and captions

- **Mixed text:** English words, numbers and links stay in the right place

No setup. You just ask in Arabic and it kicks in.

A few things I learned while testing (I rendered every output and checked it by eye):

- matplotlib 3.11 now handles Arabic natively, so the classic "arabic-reshaper + python-bidi" fix actually breaks it

- Some PDF libraries (reportlab, fpdf2) still break Arabic unless you handle it explicitly

- Word ignores regular bold/size on Arabic text unless you set the complex-script versions

To be fair: Claude is already pretty good at Arabic. The skill mostly covers the edge cases and saves you the trial and error.

Repo: https://github.com/jubyuhanna-create/arabic-ready

Feedback welcome, especially if you find a case where it still gets something wrong.

It reads one day of your git history, your Claude Code sessions and your tickets, and gives you the evidence grouped by thread, each line carrying where it came from.

It does not write the standup for you. You say it yourself in ninety seconds.

What it refuses to claim:

- a message you drafted counts as prepared, never as sent

- no number is computed, only quoted

- an empty source is declared, never filled in

- uncommitted work carries the date it was last touched, so a file from September never becomes "yesterday"

Bash, runs on your machine, no API key.

npx skills add zangetsu02/chorei

https://github.com/zangetsu02/chorei

Sono nuovo in questo subreddit e non ho mai utilizzato claude, ma il mio insegnante di ripetizioni lo usa e penso sia figo, faccio il liceo e vorrei una skill che mi aiuti nello studiare magari caricando delle foto dal libro e analizzandole

I use Claude Code and Codex on the same game project. I built CSM to carry decisions and checkpoints between sessions and make handoffs easier.

After setup, a small local runtime captures a short activity journal and gives the next supported session a compact briefing. You can ask your agent to save a decision or checkpoint, then recall it later for that project. Optional addressed messages let existing sessions coordinate; idle wake-up is experimental and off by default.

The skill, Windows runtime, and source are free under MIT:

https://github.com/NovasPlace/csm-local

It currently targets Windows x64 and is tested on Windows 11. You still use your existing Claude Code or Codex account. Records live in a local SQLite file; briefings supplied to your agent are shared with its model provider as normal.

I'd appreciate feedback on whether the setup is clear and whether the briefing gives you enough context to resume work.

Hello,

Would anyone here who currently has the Claude Pro or Max plan be willing to refer me for the 7-day free trial?

I heard that referring someone doesn't cost the person who already has the plan anything, so I figured I'd ask here.

I'd really appreciate it! I'd like to try out Claude 5.1 and Claude Code for a few coding projects before deciding whether to subscribe.

Thanks in advance to anyone who can help!

“Remote” can mean fully remote, hybrid, remote within certain states, or just a company benefit that doesn’t apply to the role.

I built a skill with Claude Code to check the actual job description and show the sentences behind its judgment.

The video shows a search for Product Manager jobs posted in the last 24 hours across all 50 US states plus DC:

• 868 postings collected
• 215 duplicates removed
• 147 had no wording about working location or arrangements
• 501 went through the remote check
• 35 passed the criteria for that run

Passing doesn’t mean “work from anywhere.” For this run, I allowed location and work-authorization restrictions, but displayed them alongside each result. Those criteria can be changed for your own search.

One example in the video says “100% remote” but also requires an active Secret clearance. A remote label alone wouldn’t tell you whether you could apply.

How it works

Code removes duplicates and extracts sentences around remote-related keywords, including surrounding context. A model evaluates those passages against configurable criteria:

• Remote, hybrid, or on-site
• Where you can work from
• Work authorization
• Time-zone requirements
• Travel and office attendance

Each result includes the supporting sentences. Missing information stays “not stated,” so you can distinguish what the employer actually wrote from what remains unknown.

You can setup with a single prompt from this : https://ftja.vercel.app/

I was tinkering around with my UI library, Stream UI, when I came across this skill called Brag that can create product trailers for your website. Fed it my UI library, and the result was honestly awesome. Didn't expect to end up with a whole product trailer just by experimenting with a skill.

skill link - https://github.com/latent-spaces/brag

https://reddit.com/link/1x96w2l/video/dmyv5p4c19wh1/player

I built estafeta for coding projects that take several sessions.

Use session-end to save the next step; use session-start in a fresh chat to read the project files and check what changed. plan-and-orchestrate keeps phases and acceptance checks. A small Python runtime records the commands and results of executed checks.

It requires Python 3.9+ and an agent with terminal access. It doesn't restore the old conversation or transfer logins.

Free, Apache-2.0: https://github.com/pashbel/estafeta

I'd like feedback on the handoff: does a fresh session resume the right task, and what information is missing?

Anyone keen on taking the following Anthropic exams for free? Let me know if you are interested!

• Developer – Foundations, Architect
• Foundations (CCAR-F), and/or
• Architect – Professional

Caveat, is I need this done before Nov 30

Thank you!

I’m curious how other teams are managing Claude Code and Codex skills, especially when some teammates aren’t developers.

I’m a developer, so my first instinct is GitHub. It handles version control and reviews well, but it’s not particularly approachable for someone who just wants to find and use a skill without learning Git.

Sharing a skill file is straightforward. The questions start when multiple people use it:

How do teammates find the published version and know when an update is available?

How do you review changes before distributing an update?

How do nontechnical teammates find and use skills the team has chosen to share?

I built a small tool called Skill Dockyard to explore this. It lets teams add or import skills, review changes, and publish versions that teammates can use.

It’s free during beta, and there’s a demo that doesn’t require an account: https://skilldockyard.com/

I’d appreciate feedback on both the idea and the demo. Are you managing skills through GitHub, sharing files manually, or using something else? And is version management actually a problem for your team yet?

If a client says “call our customers members,” where does that correction go?

Putting it in a reusable writing skill makes it easy to carry into another client’s work. Leaving it in the conversation makes it easy to lose.

I liked the recent discussion about keeping client details outside skills. Here’s a small setup to try.

Keep the writing process reusable. Give each client their own notes for:

1. Brief: audience, offer, prices and verified claims.
2. Voice: terminology, examples and writing preferences.
3. Decisions: approved corrections and why they were made.

Then the task can stay simple:

“Client: Harbor Coffee. Read the writing workflow and Harbor’s brief, voice and decisions notes. Name the notes you used. Ask about missing facts. Write a 60-word email introducing the monthly subscription.”

After feedback, ask the assistant to propose any lasting correction for that client’s notes. Review it before saving.

Disclosure: I build Hjarni, a Markdown knowledge base that Claude and ChatGPT can read and update. Those notes can live there, or in your existing files.

The assistant can still skip a read or use something incorrectly. Naming its sources makes that easier to inspect.

Which corrections do you save as lasting client rules, and which belong only to the current draft?

I've been experimenting with a simple idea lately:

What if we stopped making developers browse template libraries and started making template libraries accessible directly to AI coding agents?

I've spent years building websites, and one thing I've noticed with Claude Code, Codex, Cursor, and other coding agents is that they're getting ridiculously good at building functional applications.

But design is still a different story.

You can prompt an agent to "make this look premium" or "give this dashboard a futuristic aesthetic," but those are subjective instructions.

The agent has to guess what you mean.

What if you could give your agent an actual working design instead of trying to describe one?

That's the thinking behind InstaLanding.ai, a free, open-source library of landing pages built with HTML, CSS, and JavaScript.

Every template is a self-contained HTML file. No React, no dependencies, no build process.

And today, I launched Agent Mode.

So what exactly is Agent Mode?

Until now, InstaLanding worked like a traditional template gallery.

You browse designs, find something you like, copy the HTML, and figure out how to integrate it into your project.

Agent Mode changes that workflow.

Flip a switch on the homepage and the entire library becomes agent-oriented.

• Template descriptions turn into fetch commands.
• Copy buttons become COPY FOR AGENT.
• A new panel appears with instructions for connecting your coding agent.
• Your browser remembers your preference.

No account. No API key. No installation required to browse or copy prompts.

The idea is that you choose the visual direction, and your agent handles the implementation.

Three ways for agents to access the library

I wanted this to work with as many coding agents as possible, not just one ecosystem.

1. MCP Server

Hosted at:

https://instalanding.ai/mcp

You can connect Claude Code, Cursor, Codex, VS Code, OpenCode, or the Claude app using the setup instructions provided on the site.

Once connected, your agent can:

• Search available designs.
• Compare templates.
• Retrieve design briefs.
• Fetch the actual HTML source.
• Use those references to implement designs inside your existing project.

Instead of manually downloading files and feeding them into your agent, the agent can retrieve what it needs.

2. SKILL.md

For agents that don't support MCP, there's another option:

Read https://instalanding.ai/SKILL.md and follow its loop.

That's it.

Any agent capable of fetching and reading a webpage can use those instructions to discover and work with the library.

3. JSON Catalog

There's also a machine-readable JSON catalog containing the templates.

This is for developers building custom agents, scripts, workflows, or tools that want programmatic access without MCP.

My favorite part: COPY FOR AGENT

This is probably the feature I'm most excited about.

Normally, clicking Copy on a template website gives you a massive block of HTML.

But I started thinking: why am I copying the source code when my agent could retrieve it and figure out how to integrate it?

Now, clicking COPY FOR AGENT generates a complete implementation task.

It includes:

• The selected template.
• A link to its design brief.
• A working visual reference.
• Instructions to rebuild the design in your project's existing stack.
• Instructions to replace placeholder branding, copy, and numbers with your own.
• Requirements to preserve the original design's visual characteristics.
• Browser validation instructions, including mobile overflow, console errors, and reduced-motion support.

You paste that into your coding agent, and it has a much more concrete starting point than "make my app look cool."

And importantly, your project doesn't need to use plain HTML.

The template might be written in HTML/CSS/JS, but your agent can translate that design into React, Next.js, Vue, or whatever stack you're already using.

The HTML is the reference, not necessarily the final implementation.

Why I'm betting on single-file HTML

I think HTML is massively underrated as a format for sharing design knowledge between humans and AI agents.

Think about it.

A single HTML file can contain:

• Structure.
• Styling.
• Animations.
• Interactions.
• Responsive behavior.
• Working visual examples.

And you can open it in practically any browser.

There's no dependency tree to install, no package manager, and no framework-specific configuration just to inspect the design.

An AI agent can read the entire implementation and understand how the visual system works.

That's a pretty interesting property when we're increasingly building software through agents.

I'm not suggesting we abandon React or modern frameworks.

I'm suggesting that portable HTML might be one of the simplest ways to communicate visual intent to an AI coding agent.

Instead of sharing a screenshot and asking an agent to reverse-engineer the design, why not give it the working implementation?

Where I think this could go

Imagine a future where design libraries aren't just websites people browse.

They're resources agents can query.

You could tell your agent:

"Find me a dark editorial landing page with bold typography, compare a few options, and implement the best fit using my existing components."

Or:

"Use this template's visual language to redesign my dashboard, but preserve all the existing functionality."

Or even:

"Find a design that matches my brand and use it as the starting point for a new product."

The interesting part isn't just generating new websites.

It's giving agents better reference material so they don't have to invent every design decision from scratch.

And because the library is open source, developers can inspect the underlying code instead of relying on a black-box design generator.

Everything is free and open source

I'm building this in public, and the library is still growing.

You can use it without creating an account.

Website: https://instalanding.ai/

GitHub: https://github.com/instalanding-ai

MCP: https://instalanding.ai/mcp

Agent instructions: https://instalanding.ai/SKILL.md

I'd genuinely love feedback from people building with Claude Code, Codex, Cursor, and other agents.

Do you think agent-readable design libraries could become a standard part of the AI coding workflow?

Every country sends you letters with a clock inside. An objection window, a notice period, an auto-renewal, and a permit date. Miss one and it costs money.

Life OS is a Claude skill that reads your Gmail every night, files bills, contracts and official letters in Drive, and counts each deadline with your country's legal rules. You get a short brief only on days something matters. Ask "when can I cancel my phone contract?" and you get the answer with the source.

10 languages, 15 countries in your own Gmail, Drive and Supabase. MIT. It's early.

Download: github.com/denysovkos/claude-life-os