Skip to content

Aboard Foundry

We’re constantly exploring the possibilities AI is bringing to software development. Foundry is our hub for sharing experimental and innovative home-grown projects. Some we use in our work every day. Some are experiments we think are just plain cool. Check out what we can make.

TinyLittleOffice

Try TinyLittleOffice (opens in a new tab)

An office suite where the link is the document

Making a one-page flyer or a quick budget shouldn't require an account, a cloud drive, and a company reading over your shoulder. Six years ago Rich Ziade built TinySheet, a little spreadsheet that kept its data in the URL; it was followed by TinyCalendar, and then we moved on and the old links broke.
This year Paul Ford picked the idea back up and, working with Claude Code, grew it into a ten-app suite: word processor, slides, outliner, spreadsheets, drawing, diagrams, animation, calendar, trip planner, and more. Every document lives in the part of the URL address after the #, which browsers never send to a server, so the link is the document: copy it, paste it into chat, or print it as a QR code.

Technical addendum
Where it saves
There was absolutely nothing saved to a server. (When you put stuff after “#” in a URL, it stays local by default.)
Sharing
Copy the URL and paste it into chat. Now everyone in the chat has a copy they can edit. All your ISP can see is that you visited a site—the data is in the link.
Exporting
Export it as a document—PDF, PowerPoint, Markdown. Or as a QR code. If the document is a page or two long, the QR code can contain the whole document.
Shorter links
Shorten the URL if it’s a bigger doc by saving it to our URL shortener. Your browser encrypts the document and sends that to a server. The “key” is in the link, after the “#”—so the server never sees what you saved. (All links expire, maximum duration is a month.)
Tradeoffs
The links can get unwieldy pasted in chat, and you can’t upload video or images, full stop. It’s not collaborative like Google Docs. It’s collaborative like handing out zines at a street fair.
Agents
It was built to make sense to agents—you can tell an LLM to check out TinyLittleOffice.com and use it to make small, shareable things.
License
This project is open source with the MIT license.
So tiny, so free.
It is simply simple.
You decide how private you want your documents to be.
Maybe make a tiny presentation.
A tiny document can do big things.
Charts are calming.
Oh sweet Sankey.
Shapes!
Make it make sense.
Keep a tiny calendar.
We global.
Make a QR code, it's the document, too!
What people are saying

Conduit

Every decision from our meetings, checked by a person and backed by a quote.

Conduit is Aboard's AI communication and synthesis platform. It reads our meetings from Google Meet transcripts, Granola notes, Slack channels, and quick notes. It pulls out the parts that matter: decisions, action items, risks, and open questions, each tied to the exact words someone said.

Nothing counts until a person approves it. Each item waits in a review queue with its quote beside it, and everyone decides what to keep. Approved items become daily and weekly reports, written in a style each person designs and sent to their own Slack DM or kept in the app.

The Ask feature answers questions about our meetings. Every claim comes with its quote, and when the meetings don't cover something, Conduit says so rather than guessing.

Technical addendum
Built on
TanStack Start on Vite and React 19, Base UI and Tailwind, PostgreSQL with Drizzle ORM, and Better Auth for Google sign-in, with Anthropic models behind a single extraction interface.
The loop
Upload or pull in a transcript, extract, review (approve, edit, or reject), render in your own style, deliver. Meetings come in automatically from Granola and Google Meet, and Slack channels can be read into the same queue.
What it does on its own
One setting, from least to most automated: ask before reading a meeting, review every finding, auto-approve only findings from our own team that come with a quote and high confidence, or approve everything. Anything that skipped a human is marked as such, so it's never mistaken for a vetted fact.
Owners
Conduit names an owner only when the meeting names one and that person was there. It never guesses from who was speaking. When nobody is clearly on the hook, Conduit asks the people in the meeting whether the item is theirs, and the first to claim it owns it.
Privacy
A per-user workspace: you see and distribute only your own data. A meeting is visible only to the person who brought it in, nothing lands in a shared channel, and clients never use it.
Extensions
Optional add-ons each person turns on, starting with a Task Board that approved action items can go straight onto. Anyone at Aboard can build one in the app, as a configuration rather than code, or ship one in the codebase.
Today: what came out of your meetings, one card at a time, each with the quote behind it.
Projects: your clients and projects around you, and what each one still needs from you.
Ask: a question about a meeting, answered with the quotes behind it.
Reports: each one starts with what's new since the last, and every line leads back to who said it.
Fifteen seconds in Conduit: confirm a risk, open a project, and trace a report line back to the meeting it came from.

Flowchad

Map it before you build it, and see what you don't know yet.

Flowchad began on a client discovery call. We had to walk through a complex process, with many steps and many roles, with people who know their business cold but don't live in software. Dropping a new app in their lap would have buried them. We wanted a map they could read, mark up, and work through with us.
To use Flowchad, you describe a process in plain words: a conversation, meeting notes, transcripts. Flowchad then writes it up as a spec doc and draws a swim-laned flowchart of who does what, in what order, and where it branches. Where the description is unclear, Flowchad doesn't guess; it puts the question on the chart.
Then you walk the chart with the client and the team, answer its questions and rebuild. That's how Flowchad has moved several of our client projects forward: business logic, user experience and scope got settled on a chart before anyone built software around them.

  • Led by: Patrick Delaney
Technical addendum
Built on
A TypeScript app: a Hono API on Bun with Postgres, and a React front end whose chart canvas is React Flow with automatic layout. It runs on your own computer and your own Claude Code login, so there's no API key to manage.
The loop
Talk the process through in a chart's chat, check the spec doc it writes, build the chart, then answer its questions and leave notes on steps. Rebuild, and earlier versions stay in the chart's history.
Questions, not guesses
A rule-based checker catches structural problems (a dead end, a decision with one way out), and a second Claude pass reads the chart against the spec doc. What neither can settle becomes an open question on the chart, never an invented step.
Review without the app
One step publishes a project's charts as a private page that looks like the app. Colleagues read the charts, leave notes and answer questions there, and the next rebuild picks them up.
From chart to build
Every build saves a dated copy of the project's charts. When a prototype is built from them, Claude works from a pinned version, stops at the chart's open questions instead of guessing, and sends what the build turns up back to the chart as notes.
Tradeoffs
Flowchad maps process, not data: who does what and when, not which fields a form has. A chart is only as clear as its description, which is the point: the gaps show.
It starts as a conversation. Paste in your notes or describe the process, and Flowchad writes it up as a spec doc and asks about what's missing.
The spec doc becomes a flowchart of who does what, in what order, and where it branches.
Where the description was unclear, the chart asks instead of guessing. Select a question and the system will highlight the relevant steps in the process.
Answer a question right on the chart, then ask the chat to rebuild. Earlier versions stay in the chart's history.
Share a project's charts as a review page, so the team can read them and leave notes without opening the app.
One real run, start to finish: notes in, spec doc, chart, an answered question and a rebuild.

Evo

A tool that reflects our principles: careful planning, accelerated with AI

Evo is Aboard’s internal staff portal, the place where everyone at the company starts their day. It replaced a patchwork of paid tools and shared documents: Airtable, Greenhouse, email for expenses, and on and on. Employees use Evo to log standups and time, set their status, book desks and rooms, file expenses, track to-dos and goals, share vaults, and more. Managers get a second layer on top: project staffing, talent and recruiting, performance reviews, and reporting. Today about 95% of the company opens Evo every day, and it has saved the company thousands of dollars in subscriptions.

Technical addendum
Built on
Next.js 16 (App Router, React 19, TypeScript in strict mode), PostgreSQL via Prisma, NextAuth v5 for Google OAuth, Tailwind CSS 4, Redis caching, and Vitest for testing, deployed on Railway — with integrations into AWS S3/Bedrock, Slack, and Google Calendar.
Where AI did the work
Evo’s codebase is 100% AI-written under human guidance and review. By rebooting the project with an AI-first project, Evo is now highly adaptable—new features, guided by requirements and tests, are simple to implement and deploy.
Where humans did the work
While AI wrote a lot of code, the very human team defined requirements and defined the platform architecture. In addition, every database and API pull request is manually reviewed before merging; nothing ships on AI output alone.
Security
Evo’s API is fully closed: the only way in is Google OAuth through a 2FA company account. The credential vault uses strong, current encryption. Every database and API change goes through manual review, backed by manual penetration testing and AI-assisted review agents.
Evo opens on your day: whether your standup is in, how much PTO you’ve used, who’s out, who’s in the office, and what’s coming up.
Each morning, people split their day across projects by percentage and write a short standup. Anything under 100% shows we have room to take on more.
Everyone on a project can read the team’s standups in one place, with each person’s time on the project beside their name.
Vacations, business trips, sick days, and conferences in one list, shown in your own time zone.
Holidays for each of our offices, company events, and who’s away, all on one calendar instead of added by hand.
Book a desk on a map of the office and see who else is coming in that day.
Company-wide to-dos, assigned from one person to another with a priority and a due date. Before Evo, no tool we paid for did this.
Submit an expense with a receipt and a project, then follow it from submitted to reimbursed. This used to happen over email.
The org chart, with roles, reporting lines, and permissions kept in one place.

Designloop

Design goes in, code comes out, AI makes it easy.

Designloop began as a Figma plugin. In early 2026, we rebranded and rebuilt aboard.com on a tight deadline, incorporating some AI use in order to move fast. Figma's connector handed Claude so much raw data that it ate its working memory, so we built a plugin that captures a design once, offline: screenshots, structure and assets in one file. Designloop naturally grew around this.
Each capture becomes a design system first (colors, type, and components) that you approve before anything gets built. Then Claude reads the screenshots and writes the page, making the calls a mechanical export can't: Is this a nav? Should this stretch?
The Review feature works like Figma. Instead of describing in chat which button you mean, click it and leave a note; Claude plans the change, makes it once you approve, and checks its work. The result exports as a blueprint: plain, commented HTML that engineers and other AIs can build from. We've used it on our own site and on client work.

  • Led by: Patrick Delaney
Technical addendum
Built on
A TypeScript monorepo: a Figma plugin that captures designs fully offline, a Node command-line tool, a local review app (Express, WebSockets, and React with shadcn/ui), and Claude Code skills that write the pages. The review app runs Claude through the Claude Code CLI on your own Claude account, so there's no API key to manage.
The loop
Capture a design in Figma, approve the design system, let Claude build the page, then click to comment. When the design changes, a new capture is compared with the last one (structure, components, and screenshots), so Claude updates only what changed.
Where AI did the work
AI determines what's a nav, what should be fluid, which elements are the same component. Everything mechanical (pulling tokens out of Figma, dropping shared components into pages, comparing captures) is ordinary code, so it comes out the same every time.
Design system first
Colors, type, spacing, and components are pulled out on the first capture and wait for your approval before any page gets built. Components are written once and referenced by name wherever they appear, so fixing the nav fixes it on every page.
Handoff
One command exports a self-contained bundle (pages, assets, styles, and generated docs) that opens in any browser, ready for engineers or another AI.
Tradeoffs
Designloop transcribes the Figma file; it doesn't guess. The better the Figma (real components, with their variants set up), the better the page. Captures go one page at a time, and each takes a minute or two.
It starts here: a Figma plugin that captures a design once, offline, with every breakpoint, token, asset, and component variant in a single file.
Before any page is built, the design system is derived from the Figma file (colors, type, spacing, and components) and waits for your approval.
Claude writes each page from the screenshots and the approved system, and Designloop previews it on desktop, tablet, and mobile.
Click an element and leave a note: every comment is pinned to the exact element, so Claude never has to guess what you meant.
Claude turns your notes into a plan, makes the changes once you approve it, and returns a changelog you can sign off on or send back.
Here’s what it looks like in action!

Cadence

Our AI-driven product delivery workflow, from the first research to shipped code

Cadence is Aboard’s custom project-management and collaboration hub, and the AI-driven product delivery workflow behind our projects. Everything about a project lives in one place: the research, the feature specs, the prototypes, the milestones, and the tasks that build it.

Projects move through the same stages every time. We define the work first: the landscape, what we discovered, and the solution. Then we deliver it: feature specs set out what gets built, milestones sequence it, and tasks implement it.

Each task is built by a pipeline of AI agents, in a sandbox of its own: a planner, a coder and a reviewer, then QA, design and security passes, each checked against the task’s scope and acceptance criteria. The team gets the work back with a live preview to look at.

Technical addendum
Built on
A Hono API on Bun, a React 19 app with TanStack Router and Query, Drizzle ORM on PostgreSQL, Graphile Worker for background jobs, Better Auth, and ElectricSQL for realtime sync, with Anthropic or OpenAI models through the AI SDK. It runs on AWS.
The build pipeline
Every task runs in its own AWS Fargate sandbox. The planner maps the task to a plan, the coder implements it, the reviewer reads the diff against the scope, QA verifies each acceptance criterion in a real browser, the design pass hunts visual defects, and the security pass looks for authorization and ownership bugs in the app being built.
Containment
Cadence builds and runs other applications, so its sandboxes are built to run anything. The work is keeping each one contained: away from other projects, away from Cadence itself, with previews served on isolated hosts.
Connected
GitHub for code, Sentry for errors, and a command-line tool that lets the team work with Cadence from the terminal.
Every project has a home that grounds you in your next task based on your project status
Cadence is a tool coupled with a process, rooted in deep product work. Instead of jumping right to code, it walks you through deep discovery, research, and design thinking.
Threads, or your agentic thought partner, guide you through the entire process. Summon a thread anywhere to ask questions about your codebase, start a coding session, do web research, or all of the above
After discovery and definition, Cadence walks you through writing rich specs, the foundation of functional features.
Milestones are your roadmap, and Cadence will agentically work through the feature specs until a milestone is complete.
You can always ask Cadence for a progress report and it will update you about everything the team has worked on.
Milestones and specs are user-facing, but to turn them into code, Cadence breaks down the work into Build tasks.
Every task gets dispatched in a logical order to an agent running a full virtual sandbox, or you can work collaboratively with the agent before opening a pull request. Cadence agents write production-quality code, complete with robust test suites, automated code review, and even visual design QA. And every task gets its own preview link you can check out yourself or share with your team.
Want to explore creative design ideas? Start a prototype session, and Cadence will spin up a live version of your whole application, and you can iterate on new concepts and features.
Once you’re happy, share the link to the working software for feedback or ask Cadence to open a pull request.