Hi Everyone,

You’re getting this update because you joined a Worldwide Studios community event recently. We send an update every so often. If it’s not for you, no worries, unsubscribe below.

In this newsletter you’ll see:

1. Fall Call for Fellows: Free, Virtual and 100 days to Build

2. Final AI for Education Demos

3. Workshop Recaps and Guides

Keep building,

Michael

1. Fall Call for Fellows: Free, Virtual and 100 days to Build

We’re hosting our next set of free and virtual 100 day fellowships this fall.

Come join if you want to build with the latest in AI and hardware, explore new projects, and meet other builders. Whether you want to start a startup, a side project that earns money, or launch something new at work, this is for you.

All backgrounds welcome. Prior fellows have been researchers (no experience in AI), school owners (first build!), recent grads, engineers, and more.

How the fellowship works:

• Build new projects over 100 days in a cohort

• New demos every 2 weeks, and it’s part time at 8-10hrs a week

• Get mentorship and guidance in community to build what’s next

Application process: 1) ~10min application 2) 15min interview, and 3) build challenge.

• Applications due for AI for Education Fellowship by August 28
  → Learn more and apply here

• Applications for the AI for Science Fellowship due Sept 15
  → Learn more and apply here

Questions? Reply back.

Julia from recent Science cohort:

2. Final AI for Education Demos

Check out final builds from the AI for Education cohort. Jasjeev hit 5M+ organic views growing his sign up list to 1,000+ for PersonaLM, Xiangan ran two paid pilots for Claude Architecture Professional Certificate Tutor, and more.

Learn more

3. Upcoming Community Events

1. Claude Community SF: Science Demo Night

   Thurs ∙ Aug 20 ∙ 6:30p - 9:30p PT ∙ SF

   Come see 5+ demos for how scientists are using coding agents for new workflows.
   Learn more and sign up here →
   

2. AI Build Night: Future of Education

   Thurs ∙ Aug 20 ∙ 6:30p - 9:30p CT ∙ Madison

   Come join for a build night with Google ADK, Expo Go, or any new tool you want to try out.

   Learn more and sign up here →
   
   

We’re super collaborative in community. If you want to explore partnering for a demo night, build night, or hack, reply back.

Keep building,

Michael

Founder 🌐 Worldwide Studios

1. DIY Self Driving Lab by Dale
   Building autonomous experimentation at home

2. Benchmate by Natalie
   Seven AI agents debate each other in an Elo tournament to surface the hypothesis most worth testing

3. Pinakes Telegram Bot by Julia
   Text message an AI research assistant for reviews across 11M+ papers

4. CVMD by Sameer
   a $50 Arduino box and a browser tab that measures how well your brain actually performs against your wearable’s readiness score

5. Stapler by Akhil
   A BioScience MCP server to keep up with literature updates over time

6. bioJARVIS by Vivek
   an agent-first bioinformatics infrastructure

1. DIY Self Driving Lab

by Dale Herzog

Self-driving labs, where software designs, runs, and learns from experiments in a closed loop, have always lived inside large institutions. Dale’s project asks what it takes for *one person* to build one: the operating software, the custom instruments, and the mechatronic fundamentals underneath.

Why it matters: The real bottleneck in personal lab automation is the mechatronics. Reliable motion, actuation, sensing, and disciplined testing are what let a model’s proposed experiment actually run.

By pairing custom software with custom-built instruments, the project owns the full stack and produces a reusable roadmap others can follow.

Project Links

• GitHub Repo

• Loom Video Walkthrough

• Connect with Dale on X

2. Benchmate: AI co-scientist that debates itself for best hypothesis

by Natalie Chen

The hard part of research is deciding *which* hypothesis is worth testing. Benchmate is an open-source co-scientist where seven LangGraph agents propose hypotheses and fight it out in a pairwise Elo tournament.

The seven agents include: Generation, Reflection, Ranking, Proximity, Evolution, Meta-review, Supervisor. Winners evolve from the tournament and generate Geneformer Colab notebooks to perturb any gene you choose. Inspired by Google’s AI Co-scientist paper in Nature.

Why it matters: The hypotheses are grounded in real evidence. Agents inject cached Geneformer perturbation data and PubMed results directly into their prompts. It’s also cost-engineered: routing reasoning to Claude Sonnet 4.6 and throughput to Haiku 4.5 cuts an 8-iteration loop from ~$2.50 to ~$0.90 with no measurable quality loss.

Project Links

• Live app here.

• GitHub Repo

• Blog post

• Connect with Natalie on LinkedIn

3. Pinakes Bot: research orchestration in a text message

by Julia Gross

Julia started by hand-patching deterministic citation lookup into the paperclip orchestration pipeline. The Paperclip team shipped the same feature and happily obsoleted her work. So she redirected to the missing layer for a Telegram bot that lets you drive the whole research-digest pipeline from chat.

Why it matters: the pipeline turns a research question into a citation-anchored evidence digest across 11M+ papers, but launching it meant CLI flags and prompt files. Pinakes puts that behind a message.

Project Links

• GitHub Repo

• Blog post

• Connect with Julia on LinkedIn

4. CVMD: measuring the mind from a $50 box to a browser tab

By Sameer Shah

Do the “readiness” scores our wearables hand us every morning actually correspond to how well our brains perform? CVMD measures cognitive performance directly through reaction time and checks it against the biometric story. This update explore a web app that complements the Arduino device. Same reaction-time tests, now in a browser.

Why it matters: the main exploration right now is measuring cognitive readiness through variability is the response data, not speed of reaction-time. The reaction time spread moved 242% across impairment states vs. just 76% for average reaction time.

Project links

• Live App Here

• Blog post

• GitHub

• Connect with Sameer on LinkedIn

5. Stapler: a literature search that never goes stale

by Akhil Devarasetty

A systematic review is obsolete the moment you finish it. Stapler fixes that. It’s a local BioScience MCP server that unifies PubMed, NCBI Gene, ClinicalTrials.gov, and RAG over your own PDFs behind one interface — and its SQLite engine snapshots the topics you care about and diffs new PubMed literature over time, turning a one-time search into a living review.

Why it matters: literature never stops moving, and re-running searches by hand doesn’t scale. Stapler keeps the review current automatically, runs entirely on your machine (private by default, with a llama.cpp bridge for fully local models), and drops straight into Claude Desktop, VS Code, and Cursor.

Project Links

• GitHub Repo

• Blog post

• Connect with Akhil on LinkedIn

6. bioJARVIS: infra for agents

by Vivek Ramaswamy

AI agents can finally explore hypothesis space at the scale the combinatorics demand but our bioinformatics tooling was designed for a human asking one question at a time. JARVIS for Bio v0 is an inference-oriented architecture that rebuilds that plumbing for agents, and proves it on a real problem: reasoning from an AMD GWAS hit to a mechanistic hypothesis across levels of biological organization, with full provenance on every claim.

Why it matters: The core move is separating writing from reading. Heavy compute (protein folding, indexing, enrichment) happens once in batch, ahead of time, so the agent only does fast schema-typed reads at hypothesis time. The payoff: the same six-gene AMD analysis takes ~30 hours by hand vs. ~4 minutes warm (~430× faster), with reasoning now 87% of runtime and retrieval negligible.

Project links

• Video post

• GitHub repo

• Connect with Vivek on LinkedIn

Follow for new builds every 2 weeks.

Worldwide Studios is an education nonprofit on a mission to help anyone build anything. We host 100 day fellowships, like this AI for Science fellowship, for people to explore the latest tools through ambitious projects. Learn more here.

1. PersonaLM
   Learn complex topics from your favorite characters

2. Whetstone
   Professional certificate tutor for Anthropic’s new CCA Exam

3. Sarto
   Students building AI solutions for small businesses

4. AEO Grader
   Improve Website Discovery in the Agentic Era

5. ThinkHigher
   Scenario based training for students to become data analysts

6. Strata Mundo
   Personalized math games for middle school students

1. PersonaLM: Learn Complex Topics from your Favorite Characters

By Jasjeev Singh

Jasjeev was a content creator who enjoyed making educational videos. During the the fellowship, he kicked around a number of ideas before landing on Persona AI. His main inspiration is ensuring his neurodivergent brother has a better education experience than the current status quo.

Educational content and curriculum is boring. It’s hard to stay engaged and there’s no current personalization. PersonaLM is a platform that enables any student to build custom characters paired with their own content material.

Why it matters

52% of K-12 students report not being engaged at all in their learning. They’re bored and understandably so from generalized curriculum. The answer to kids being bored is to meet them where they are and personalize differnet kind of support.

Main progress over 100 day fellowship

He hit 5M+ organic views in 30 days, grew waitlist to 1,000+, and started his first beta pilot to understand how users create and interact with new characters.

2. Whetstone: Professional certificate tutor for Anthropic’s new CCA Exam

By Xiangan He

With the introduction of requirements for the Anthropic exam at several of his clients, Xiangan saw a new problem. Many developers had to pass the exam to keep their job. With the exam being brand new, there wasn’t a lot of support to prep.

With Whetstone he built an immersive tutoring environment that helps people pass it on their first try. It’s important because there’s a 6 month cool down if they fail.

Alongside Anthropic’s CCA exam, he also piloted it for CISSP Certification for cybersecurity.

Why it matters

72% of people fail certifications like the OSCP on their first try. At the same time certifications are either requirements for an increasing number of careers or they lead to significant increases in wages or salary. New personalized tools enable higher probabilities for success.

Main progress over 100 day fellowship

He ran 2x paid pilots for the Anthropic CCA tutor. One with a major developer agency and another with a consulting firm. He also ran one pilot with BU students with the CISSP tutor.

3. Sarto: Students building AI solutions for small businesses

By Ryan Leong

Ryan took a leave of absence from college because it did not offer a way to keep up with the latest in AI. As he talked to other students, he also saw a big gap between what different businesses were asking for and what students wanted to help build.

His idea is to connect businesses with aspiring builders, who are currently students, to ship AI native solutions. From customer service support agents on Whatsapp to agentic workflows to automate back of office work, Ryan helped connect real needs from businesses to students who wanting to ship real solutions.

Why it matters

For the first time, college graduates have a higher unemployment rate than non-grads. It’s higher than the national average.

This trend is often blamed on AI but when polled business owners and hiring managers regularly cite a lack of college education lining up with real world requirements of the job.

Getting students that experience is critical to bridging that gap, and Sarto pays them to do it.

Main progress over 100 day fellowship

He ran one paid pilot himself with an automation for real estate business, and had talked to several local businesses and worked with five students to help them build solutions for those businesses.

Project Links

• Student Demos on Notion

4. AEO Grader: Improve Website Discovery in the Agentic Era

By Feodor

Everyone who runs a business on the internet knows SEO. Add specific keywords that map to your business on your website and get discovered by search enginers like Google.

Now on the internet there’s AEO, Answer Engine Optimization, where results get summarized by LLM bots reading websites. From web search in ChatGPT or Claude and Google’s new answer box, AEO is important for businesses to rank for new internet searches.

Feodor saw that his country, Russia, was falling behind in both adoption of AI but also in best practices. So he set out to build a tool to bring insight to businesses and tap into the budding market there.

Why it matters

In the age of AI, people are having conversations with AI agents and getting specific recommendations. AEO is key to making sure a business or app shows up in those convos.

Main progress over 100 day fellowship

He piloted an early version of a teaching platform with his team, Jay and Harsh. For their AEO build, they talked with dozens of businesses for feedback on painpoints.

Project Links

• Github Repo

5. ThinkHigher: Scenario based training for students to become data analysts

By Joseph Ching, Lillian Gong + Morgan Hough

There’s a gap between what students are learning in the college classroom and what employers want to hire for.

And there’s a large disconnect between hundreds of one click applications and the filtering systems trying to make sense of resumes and answers.

So the team brought together their research experience to come up with a simulation based tool that enables students to practice tasks in a virtual, team based environment.

Why it matters

Async communication is just as important today as doing the work. Interview processes are also linear and one way paths, with often no feedback. Creating a platform where students can practice and get feedback on both their process and their communication enables more context to evaluate connection in the hiring process.

Main progress over 100 day fellowship

They piloted with two student consulting clubs, and they validated feedback on the scenarios from industry experts.

Project Links

• Github Repo

6. Strata Mundo: Personalized math games for middle school students

By Barbara Jauregui Wurst

Everyone knows someone who “hates math” or doesn’t see the point. For Barbara, that was her brother. Despite not being supported in school, he’s a successful car mechanic now running his own garage.

Barbara, a mother and owner of an Acton Academy, knows this problem all too well and set out to build an answer to it.

Her idea: build a system to gauge a learners understanding of mathematics and then use games to grow both their knowledge and their love of math.

Why it matters

Math isn’t just useful for crunching numbers. It’s likely that many more people would likely find passion for the field if they were making video games rather than learning by repitition on a black and white sheet of paper (or screen.)

Main progress over 100 day fellowship

Barbara ran a pilot at her Acton Academy to get feedback from middle school students. She even ran a workshop to help them design their own games.

By the end of the fellowship, she grew a pipeline of 26 interested schools and owners to explore a co-operative model.

Other builds throughout the fellowship

• Sasha built out interactive curriculum management systems to connect higher ed professors with their students in large 1,000+ person lectures.

• Mike and Scott built early on project based learning guides with Barbara.

• Xiangan built a middle school math tutor platform in first week with real paying customers and demos.

• Jasjeev worked with Vedansh on an online math tutor for paid pilot.

Follow along for more builds.

Worldwide Studios is an education nonprofit on a mission to help anyone build anything.

We host 100 day fellowships, like this AI for Education fellowship, for people to explore the latest tools through ambitious projects.

Next round of fellowships are live here.

We’ve hosted 1,000+ builders, researchers, founders and engineers for AI Science hacks in SF, like this recent one with Monomer Bio in SF.

Our goal for this free fellowship is help people around the world continue to build. It’s virtual. No need to be physically in SF. We want to help people keep up with the latest in AI and hardware. Have a community to build and experiment with support.

Intro to this batch of fellows

Dale is in Fresno, California with a background in SolidWorks CAD and mechanical drafting. He’s sketching up a T75 Flask Decapper to 3d print for lab automation workflows.

Mohamed is joining from Malaysia with a background in EE and robotics control software. His first project is a personal OpenClaw agent deployed on Ubuntu with a Telegram channel, Gemini Flash backend, and four custom skills, including /papers for live arXiv search and /brief for daily briefings from a JSONL store.

Natalie is a molecular cell biologist in South SF, who’s been building since her first project with Fifty Years during their 5050 program. Her first project is a protocol generator agent that takes in files and documents and generates new lab protocols.

Akhil is in Fremont, CA, stepping into a new role as a test engineer. He built a privacy mirror to safely share data with an LLM and recover the original information back.

Julia is a scientific consultant from Cambridge, MA. Her first build used Karpathy’s autoresearch for classifying heart monitoring data.

Sameer is coming with a strategy and operations background from New York. And his first project explored how to design next steps in protocol design.

Vivek is building autonomous learning systems for labs. His first project was a digital twin setup for a beehive exploring swarm patterns.

If you want to help pay it forward and give feedback to current fellows, reach out.

We have project demos every 2 weeks.

Worldwide Studios is a CA 501c3 education non-profit helping professionals build with the latest in AI, hardware, and applied sciences.

Your goal: Try out Claude Design to make 1 good slide. There are many paths to get there, try to see how far you can get by only prompting in the chat before trying the custom features like design systems.

Why: Understanding the baseline of a tool out of the box will help you see the gaps and get familiar with new environment.

If you start trying all of the things, like add a custom design system at the start, then you won’t have a sense of what’s causing different results as you go through new workflows.

Introduction

In most design software, what you type is what you get.

To make things look good, you need to make decisions like font, spacing, composition, and tweak 20+ parameters yourself. Or if you use a template, it looks like you used that template.

When that same text is typed into a prompt for Claude Design, it kicks off an agentic workflow that writes code and loads in design references to make a more finished product.

1st Prompt input

1st Output

Same effort in (zero). Same words. Different results. Claude Design starts reasoning and deciding on different design decisions knowing it’s trying to make slides. Design software defaults as a blank canvas. Claude Design defaults as a design assistant taking words (and extra context) to lay out the canvas.

Does that mean everyone has to start being fluent in design fundamentals to prompt Claude Design? Well, not really.

Something as simple as knowing something is off and calling it out can get different results.

2nd Prompt Input

2nd Output

From a vague one line prompt, it ran with it and took 18 steps to make this second iteration in 2 minutes. One interesting feature is there’s a self verifying loop, where Claude Design loads the HTML and takes a screenshot to feedback to itself. That way it’s not one shotted, but actually looks at it’s first draft to decide what to update.

In Claude’s own summary, here’s what this second prompt kicked off:

1. Received “make it better” feedback from the user.

2. Rewrote Slide.html (v2) via write_file — added Fraunces + JetBrains Mono from Google Fonts, 180px serif headline split into 3 indented lines, paper grain background, inset border frame, topbar with “A Principle / § 01,” an ampersand circle mark, a two-column grid with “Thesis” label + headline on left and “Nothing more. / Nothing less.” coda + rule + “Verbatim · No magic” meta on right, and a bottom bar with “Input → Output / 01 / 01.”

3. Called done — validators flagged 5 under-24px text issues (Thesis 22px, Verbatim/·/No magic 18px, Input→Output 20px) plus a headline line-overlap.

4. Applied 5 edits via str_replace_edit — bumped topbar to 26px, label to 26px, meta to 26px, bottombar to 26px, and reduced headline to 172px with line-height 1.02.

5. Called done — still flagged a 5px headline line overlap.

6. str_replace_edit — dropped headline to 160px and loosened line-height to 1.1.

7. Called done — still 11px overlap.

8. str_replace_edit — kept 160px, loosened line-height to 1.18.

9. Called done — new overlaps appeared (headline still, plus right column colliding with bottombar).

10. Ran save_screenshot → check.jpg and view_image to see the state.

11. Diagnosed visually: headline indents too deep (forcing “what you get” to wrap awkwardly), right column meta colliding with bottom bar.

12. Registered a snip for messages m0002–m0012 to clear resolved iteration history.

13. Overwrote Slide.html (v3) via write_file — reduced to 2 headline lines (line1 unindented, line2 indented 1.2em), centered headline vertically with top: 50%, moved “Thesis” label to absolute position below topbar, placed coda in lower-right with short rule above it, simplified bottombar to “Input → Output” / “Verbatim · No Magic,” kept ampersand mark in top-right, 168px font-size with line-height 1.04.

14. Called done — validator flagged one remaining 16px headline overlap.

15. Ran save_screenshot → check2.jpg and view_image to verify.

16. Confirmed the overlap was a false positive from Fraunces descenders (p, y tails) with no actual visual collision.

17. Registered a second snip for messages m0013–m0019.

18. Called fork_verifier_agent to run a background sweep and ended the turn.

And so when prompted “make it better,” it started to decide what “better” means.

This may not have been what was meant by “better,” as it was really open ended.

And so in the next prompt, let’s see what 1) sharing specific details do and 2) giving it a visual direction by analogy for context.

3rd Input

^ specific details: “too formal and cluttered” with visual direction: “like a cool sneaker brand.”

3rd Output

It switched up the design with new colors, backgrounds, bolder fonts, and new layout. It updated the copy to be more informal, but it didn’t really address: “cluttered.”

So one more update:

4th Input

4th Output

It’s a bit too minimal, as some texture from the last one like the edge boarder was nice, but it did listen to remove as much as possible.

This could continue on for another 1-10+ prompts tweaking the exact result, and that’s the process of working with Claude Design from blank chat. There’s one output and with more feedback, directions, and ideas, another output.

But not all chats need to start from scratch, there can be more details at the start.

Whenever going through a long chain of iterations, a helpful final prompt is:

That compresses the process and shows how the system would explain the output to itself. That trick can also be used to make skills for agents.

We’ll feed that back in to see how closely that one step will get to the same output.

Some other examples of design prompting starting points

1. Starting with a more specific prompt

Taking the above and pasting it into Claude Design, here’s the first result below. We got in 1 step what took 4 before. The longer the chain, the more helpful this compression becomes for better prompting to start.

Here’s the prompt that Claude suggested:

Make 1 slide at 1920×1080 that says “What you type is what you get. Nothing more. Nothing less.”

Style: modern sneaker-brand / streetwear aesthetic. Dark near-black background (#0e0e0e), heavy uppercase Archivo Black headline around 150px, one bold volt-yellow accent color (#d6ff3d). Put the main phrase on two lines with “what you get” wrapped in a skewed volt-yellow highlight block (black text inside, ~6° skew). Below the headline, smaller dimmed gray text reads “Nothing more. — Nothing less.” separated by a short volt-yellow horizontal rule.

Extreme minimalism — no nav, no numerals, no tags, no frames, no kickers, no labels, no icons. Just the headline and the coda, centered vertically with generous horizontal padding (~260px each side). Maximum whitespace.

2. Starting with a website, like Nike’s home page.

The prompt:

Make me 1 slide that says: What you type is what you get. Nothing more. Nothing Less.

Based on this website design: https://www.nike.com/

While Claude Code can scrape the web to make sense of things, the Claude Design team made sure that scraping one guardrail from the chat interface, as it replied:

I'll create an original slide with that message. I won't recreate Nike's branded design (different domain), but I can build a bold, athletic-style slide with strong typography and high-impact composition — which is the underlying design approach that works well for punchy statement slides.

There are other ways to import and set up design systems, like code bases and figma files, and so importing from website links right now is not one of them.

3. Starting with an image for inspiration, like the Hoppers movie poster.

This combines the first prompt “Make me 1 slide that says: What you type is what you get. Nothing more. Nothing Less.” with an image. Adding images helps set direction.

While it got the color right, it over indexed on the seriffed font and is text heavy. One thing to explore next is how to make slides more visual with images and graphics. It may be a limit to the starting prompt or it may be a different feature to work within the new tool.

Other features to try out in Claude Design

1. Tweaks and ideas. This looks like Claude Code planning mode with a bit more self direction. It kicks off a self review where Claude explores paths to make the design better.
   Based off the paths it finds, it makes a panel for you to find tweaks you like. This is helpful. It’s more collaborative than a chat alone. And dynamic for quick testing.

   

2. Draw and sketch feature. The annotation on the design to add notes to feed to Claude Design is a nice feature. It mimics sitting down with a red pen to annotate a design.

   

3. Share design for comments. Real feedback from other humans. Helpful.

4. Export to Canva , PPTX, or Handoff to Claude Code. Baked in to day one really shows how this may not be meant to be a final production tool. It may be enough to get a prototype up and finish elsewhere.

5. Set up design system. Set up branding and design schema based on website or files already created.

First impressions

It’s fun to have a new interface that’s not a terminal or a chat desktop app.

It’s the first application that explores how the core agent loop with Anthropic’s large language models like Opus, Sonnet, and Haiku can focus on specific workflows that were previously not coding problems.

While it’s very much in research mode, where the spatial commenting seems limited for immediate updates, it’s the first real product outside of code generation that Anthropic released. One thing it does well is not gate keep the work. It’s easy to export in different file types, like PDF, download the code, or import right into Claude Code.

Exchanging context will be important for platforms as many people are going between tools. For example to respond to this release, Google actually open sourced their draft spec for DESIGN.md to go from tool to tool and project to project.

And this is only a start of a product roadmap where agent loops start being the core in custom applications.

Let’s see what’s next: marketing, sales, legal, education, finance, etc. At the rate the Claude Code team has been shipping, who knows the pace of new product releases.

Written by Michael, co-founder of 🌐 Worldwide Studios, a CA 501 c(3) education non profit. Reach out if you want help exploring design with new AI tools, whether it’s Claude Design or Claude Code, Open AI Imagen 2.0 or Gemini Nano Banana.

Hi Everyone,

You’re getting this update because you joined a Worldwide Studios workshop or community event recently. We send an update every week or two. If it’s not for you, no worries, unsubscribe below.

In this newsletter you’ll see:

1. Update on AI for Science Summit (June 16-17)

2. TutorMax Product Update: Claude Code sessions

3. Workshop Recaps and Guides

Keep building,

Michael

1. Update on AI for Science Summit (June 16-17)

We’re hosting our first 100+ person summit in SF June 16-17 focused on the latest in AI in Science with the theme of the “agentic scientist.”

We’ll have 20+ speakers as well as hands on workshops to cover:

• How does the role of the scientist and engineer update with new tools like AI co-scientist tools or more agentic hardware?

• How does the lab evolve with new self driving systems?

• What role do different machine learning models play in different parts of experimental workflows, like how are new world models allowing more flexible benchtops?

We have speakers confirmed from Genentech, Cellares, Y Combinator founders, National Lab researchers, and more. Early bird tickets are 50% off at $195.

Learn more and get your ticket here

Co-hosted with Bay Area Lab Automators, Hardware Meetup, and supported by Opentrons. If you want to help sponsor or support the summit, send a note.

2. TutorMax Product Update: Claude Code sessions

We’re currently piloting TutorMax, a tool that helps people learn new skills like prompting. This week we got it working with Claude Code for multi session feedback. Check out the build in public update below in a 2 part session for starting to build a 3d video game.

Check it out

If you want to try out TutorMax, check out the workshops below. We’re piloting it in different hands on sessions. And if you have a custom curriculum request, reach out.

3. Upcoming Workshops and recaps

1. Make Slides with New Claude Design Tool

   Wed ∙ April 22 ∙ 4:00p-5:00p PT ∙ Virtual ∙ Ticketed

   Get hands on experience trying out Anthropic’s new design tool.
   Learn more and sign up here →
   

2. Make custom coloring books with Gemini AI

   Sat · April 25 · 11a-12p PT · Virtual · Ticketed

   Use Google’s latest AI model that makes images - Nano Banana 2 - to make custom coloring book pages. This is a fun one for families or people looking for a weekend project.

   Learn more and sign up here →
   

3. Build your first iOS App with Rork

   Thurs · April 30 · 6p-9p PT · SF · Ticketed

   ​Build your first (or next) app with Rork.com. Rork is a no code builder for mobile apps.

   Learn more and sign up here →

Recap

• Build Guide: Here’s an overview of how to build OpenClaw’s agent loop in 20 lines of code. It’s a recap from a workshop in SF.
  

Have something you want to see a workshop for? Reply back as we’re taking custom requests.

Keep building,

Michael

Founder 🌐 Worldwide Studios

Ps. We’re running 2hr AI agent build along workshops for teams and communities, like this one for MIT Sloan Alumni. If you want to see one for your role or your team, reply back as we’re designing these with community members for specific use cases.

TutorMax Now Works With Claude Code

Prompting is a skill. You don’t get good at it by reading tips or staring at a blank prompt box. You get good by doing reps with real feedback on real work. Most “learn to prompt” content is static: read it, nod, never apply it. The loop is broken.

TutorMax fixes the loop. It helps you as you build, calls out incomplete prompts, and gives you feedback to to write better ones.

What’s new

Run tutormax login in any repo. TutorMax hooks into your Claude Code sessions from there. Every prompt and diff in a session TutorMax sees it, summarizes it, and feeds it into the next step of your curriculum.

This helps go from single session for prompt updates to multi-session, where what gets shipped in Claude Code helps shape the next session on TutorMax.

Example: a 3D platformgame

The video above shows “build a 3D platformer” path.

Step one started lazy: “generate a 3D platformer where the player is a sphere.” A few rounds of feedback turned it into a real spec with colored platforms with effects, orbit camera on the arrow keys, bouncy Mario-style physics, cel-shaded look.

One Claude Code run later led to working game.

Step two was adding enemies. Starting with a simple prompt like “an enemy that’s two spheres tied together, circling the platforms” left out important details. TutorMax called it. The challenge asked for variety. This prompt wasn’t grounded in the world just built from the first prompt.

To expand it, the prompt got updated to:

• Two purple orbs chained together, eyes on the front, circling the round platforms.

• A yellow pyramid that puffs up in smoke and smashes down.

• A grey cube tumbling like a thrown die, ignoring the player entirely.

Plus a constraint: one enemy per platform, some platforms empty.

TutorMax gave a thumbs up.

Claude Code built it.

The diff got auto-summarized and fed into the next step. Designing a boss. Stay tuned for next update.

We’re doing a private pilot right now for TutorMax

If you want to learn Claude Code with TutorMax, or have an idea for your own curriculum, reach out! We’re piloting with different builders right now.

Written by Dylan, co-founder of 🌐 Worldwide Studios, a CA 501 c(3) education non profit. He’s on a mission to help anyone build anything in the intelligence age.

Last week 520k lines of code leaked from Anthropic to show how Claude Code runs. If you’re curious, here’s one write up. This is one of the strangest security breaches of the year: one of the top closed AI agents was accidentally made open sourced from a source map file that was not removed in review process.

The way the team plans to fix that kind of breach from happening in the future? More Claude Code in the process.

At the same time as that was happening online, we ran a workshop in person with Will Sentance, founder of Codesmith and fellow at South Park Commons, for how to write an agent from scratch in 20 lines of code.

Inspired by the intentionally open sourced agent, OpenClaw, this walks through how a self improving agent loop is built from the ground up in JavaScript. It covers the essentials for a self improving agent that can be run locally, which can add its own skills and tools, better design its own TUI, and more. All built within 2 hours, line by line, with many people joining having no technical background.

This workshop was supported by Titus Capilnean and Nancy Li of Civic Technologies , helping ensure agents are secure from run one with guardrails and permission management.

The agent loop

Every AI coding agent, including Claude Code, Cursor, Devin, Codex, OpenClaw, runs a version of this same loop. The user types in a message which gets sent to a large language model that decides if it will use a tool and what tool to use. As it calls a tool, it runs the command and feeds back the tool and result to the large language model, looping until it decides to break and print message. There can be different tools and different parts to the loop, but this is the simplest agent loop.

The workshop structure and code

Setup: Install Bun, get an OpenRouter API key, verify the connection

01 Curl Basics: Talk to an AI model with raw HTTP. Understand POST, auth, and the message format.

02 Pipe & Execute: Extract the AI’s response with jq and pipe it into bash. Use natural language to generate the commands used in step 1.

03 JavaScript Agent: Move from curl to fetch, from jq to JSON, from piped bash to Bun.$

04 While Loop Agent: Add memory (messages array) and retry logic (while loop that feeds errors back)

05 Tool Calling: Structured tool use — the AI signals “run this” vs “here’s my answer”

Extra builds

• Skills System: Extend the capabilities of the agent with markdown files. No extra code.

• Ralph Loop: Solve the context management problem with continuous looping and a log of progress.

👉 All of the code here. h/t Dennis Corsi and Will Sentance 👈

Here are the 20 lines:

const messages: { role: string; content: string }[] = [
  { role: "system", content: "Return only mac bash commands. No backticks. Output raw string only." },
];

for await (const line of console) {
  messages.push({ role: "user", content: line });

  while (true) {
    const data = await (
      await fetch("https://openrouter.ai/api/v1/chat/completions", {
        method: "POST",
        headers: { Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}` },
        body: JSON.stringify({ model: "openrouter/free", reasoning: { exclude: true }, messages }),
      })
    ).json();

    const message = data.choices[0].message;
    messages.push(message);

    try {
      await Bun.$`sh -c ${message.content}`;
      console.log("✓", message.content);
      break;
    } catch (error: any) {
      messages.push({ role: "user", content: `Command failed: ${error.message}` });
      console.log(`✗ Failed: ${message.content}. Retrying...`);
    }
  }
}

A walkthrough line by line:

That’s the whole agent. The while(true) is the engine. It chains as many tool calls as it needs (list files, read one, edit it, run tests). Each tool run and response gets added back into the message array and sent back to the large language model for next steps before it decides to respond with text and break.

Building the agent loop step by step

01: From Nothing to Talking to an AI

Before anyone wrote a single line of code, we needed two things: a way to run JavaScript (Bun), and a way to talk to AI models (an OpenRouter API key). Challenge 00 was the setup: install Bun, create a free OpenRouter account, copy your API key into a .env file, and run a quick curl command to make sure everything was wired up.

Then came the first lesson: what actually happens when you “talk to an AI”?

Challenge 01 stripped away every layer of abstraction. No SDK, no library, no chatbot UI. Just curl, a command-line tool that makes raw HTTP requests. The same thing your browser does a thousand times a day. Now in the terminal to see each step building up to the API call.

First, hit the URL:

curl https://openrouter.ai/api/v1/chat/completions

404 error. Curl defaults to a GET request, and this endpoint only accepts POST. HTTP has methods, and we’ve got to use them.

Next, switch to POST by adding a body:

curl https://openrouter.ai/api/v1/chat/completions \
  -d '{}'

401 error. Different number, different problem. The server received the request this time. It just doesn’t know who you are. That’s authentication.

Add an API key in a header:

curl https://openrouter.ai/api/v1/chat/completions \
  -H "Authorization: Bearer $OPENROUTER_API_KEY" \
  -d '{"model": "openrouter/free", "reasoning": {"exclude": true},
       "messages": [{"role": "user", "content": "Say hello."}]}'

A real response comes back. a big JSON blob with the model’s reply buried inside at choices[0].message.content. That’s the large language model responding. 404 → 401 → 400 → message walks through method, auth, and required fields.

02: From Reading a Response to Running It

Challenge 01 ended with a JSON blob on screen. The AI’s reply was in there, but buried under layers of metadata, including choices, message, content, role. To extract the reply, use pipes, the | character in bash that takes the output of one command and feeds it as input to the next.

It helps chain tools together like the plastic knobs of a lego piece connecting other pieces.

The first tool chained is jq, a command-line JSON processor, that pulls out the exact value. It’s combined with the -r flag to strip the JSON quotes to guarantee a raw string. This turns a noisy API response into a clean, usable command.

The build-up went like this:

Step 1 — Pretty-print the full response to see what you’re working with:

curl [the full API call] | jq '.'

Step 2 — Extract just the AI’s reply:

curl [the full API call] | jq -r '.choices[0].message.content'

Now the only thing on screen is the raw command the AI generated, like screencapture screenshot.png.

Step 3 — Pipe that command straight into bash:

curl [the full API call] | jq -r '.choices[0].message.content' | bash

A screenshot appears on your desktop.

Three tools, three pipes:

• curl fetches the AI’s response

• jq extracts the command

• bash runs it.

Now any sentence can be typed in natural language to get your computer to do a thing like take a screenshot. No code, just three existing unix tools stitched together with a large language model.

It’s important to say this can be dangerous as the large language model can return any command that can run locally, like delete all files. In production this would sandbox execution, have a human in the loop, and/or validate commands.

03: From Bash Pipes to Real Code

The curl pipeline from Challenge 02 was like magic: English in, screenshot out. But it was also held together with tape. If the LLM returned a markdown code fence around the command, it would break. If the command failed, you’d get a cryptic error and no way to recover. If you wanted to ask a follow-up question, you’d have to retype the entire curl command.

This next step is about translating the pipeline into JavaScript, with real data structures, error handling, and control flow. The good news is it’s a one to one translation. Every piece of the curl pipeline has a direct JavaScript equivalent.

First, curl with headers and a JSON body becomes fetch, JavaScript’s built-in way to make HTTP requests:

const response = await fetch("https://openrouter.ai/api/v1/chat/completions", {
  method: "POST",
  headers: { Authorization: `Bearer ${process.env.OPENROUTER_API_KEY}` },
  body: JSON.stringify({
    model: "openrouter/free",
    reasoning: { exclude: true },
    messages: [{ role: "user", content: "Return only a mac bash command to take a screenshot." }],
  }),
});

jq -r '.choices[0].message.content' becomes plain JavaScript property access. Once JSON is parsed, you just navigate the object:js

const data = await response.json();
const cmd = data.choices[0].message.content;

| bash becomes Bun.$, Bun’s built-in shell API that lets you run commands from JavaScript:

await Bun.$`sh -c ${cmd}`;

That’s the script. Run it with bun run agent.ts and you get the same screenshot, but now you’re in a real programming language. You can add console.log(cmd) to see what’s about to run. You can wrap things in try/catch. You can build on it.

The point of this challenge wasn’t to do anything new. It was to prove that the curl pipeline and the JavaScript version are the same thing with the same URL, same headers, same body, same response shape. The only difference is that now you have a real language under you instead of duct-taped shell commands.

04: Making an “Agent” with memory and retry

Challenge 03 was a one-shot script: send a message, get a command, run it, done. If the command failed, the script crashed. If you wanted to ask something else, you had to re-run the whole thing. There’s no conversation, only a single request and a single response.

To start to turn it into an agent, there are two things that get added: a messages array and a while loop.

The messages array is the AI’s memory. AI models are stateless, meaning they have zero memory between API calls. It’s like waking up with amnesia. Every time you call the API, you have to send the entire conversation history from scratch. The model reads all of it, generates a response, and immediately forgets everything.

So if you want context across turns, you have to maintain it yourself.

const messages = [
  { role: "system", content: "Return only raw bash commands. No backticks." },
];

That array starts with a system prompt and grows with every exchange. When the user types something, you push a { role: "user" } message. When the AI responds, you push its message too. Next time you call the API, the model sees everything that’s happened so far.

The while loop is what gives the agent persistence. Instead of crashing on failure, the loop catches the error, pushes it back into the messages array as a user message (”that command failed, here’s the error”), and lets the AI try again:

while (true) {
  // call the API with the full conversation...
  const message = data.choices[0].message;
  messages.push(message);

  try {
    await Bun.$`sh -c ${message.content}`;
    break;  // worked → exit
  } catch (error) {
    messages.push({ role: "user", content: `Command failed: ${error.message}` });
    // loop continues → AI sees the error and tries a different approach
  }
}

Wrapping all of this in a for await (const line of console) loop means the script stays alive between tasks. Type an instruction, the agent executes it (retrying if needed), then waits for your next instruction with full memory of what just happened.

We went from running a script to talking to something. You can now say “take a screenshot,” then say “open that file” and it would know what “that file” meant because the conversation is in the messages array.

05: Tool Calling — The Clean Protocol

Everything up to this point had the same fundamental hack at its core: we told the AI “respond with a raw bash command and nothing else” and hoped it listened. Sometimes it did. Sometimes it wrapped the command in backticks. Sometimes it added “Sure! Here’s the command:” before it. Every one of those variations would break the script.

Tool calling replaces that hack with a real protocol. Instead of hoping the AI returns a clean string, you tell the API “this model has access to a tool called bash that takes a command argument.” Now the AI has two distinct ways to respond:

Option 1 — it wants to run a command. The response comes back with a tool_calls field containing structured JSON:

{
  "role": "assistant",
  "tool_calls": [{
    "id": "call_abc123",
    "function": {
      "name": "bash",
      "arguments": "{\"command\": \"screencapture /tmp/screenshot.png\"}"
    }
  }]
}

Option 2 — it wants to give a final answer. The response comes back with a content field containing plain text:

{
  "role": "assistant",
  "content": "Done — screenshot saved to /tmp/screenshot.png."
}

No ambiguity. You check one field — message.tool_calls — and you know exactly what the AI wants to do. The command is always cleanly extracted from structured JSON, never parsed out of free text.

You define the tool as a JSON schema that gets passed in every API request:

const BASH_TOOL = {
  type: "function",
  function: {
    name: "bash",
    description: "Run a bash command on the local machine",
    parameters: {
      type: "object",
      properties: { command: { type: "string", description: "The bash command to execute" } },
      required: ["command"],
    },
  },
};

And the loop logic becomes a clean if/else instead of a try/catch:

if (message.tool_calls) {
  // AI wants to run a command
  messages.push(message);
  const toolCall = message.tool_calls[0];
  const { command } = JSON.parse(toolCall.function.arguments);
  const result = await Bun.$`sh -c ${command}`.text().catch(e => e.stderr || e.message);
  messages.push({ role: "tool", tool_call_id: toolCall.id, content: result });
  // loop continues — AI sees the result
} else {
  // AI is done — print and break
  console.log(message.content);
  break;
}

There’s a new message type here: role: "tool". In Challenge 04, we pushed errors back as role: "user" messages. That was a hack. We were pretending the user said “that failed.”

With tool calling, there’s a proper role for tool results. The tool_call_id field links the result back to the specific request the AI made, so when the model reads the conversation history, it knows exactly which command produced which output.

The other big shift: the loop no longer breaks on successful execution. It breaks when the AI decides to respond with text. That’s an important difference.

This is the final form. The 20 lines of code are the same pattern running inside Claude Code, Cursor, Codex, and every other AI coding tool. Different tools plugged in, better error handling, more guardrails — but the same loop.

Open build: agent skills

We had some time at the end for people to use their new agent and make it better.

We covered agentic skills, a way to log workflows, context, and samples as a markdown file the agent can use.

• Want the agent to log every command it runs with a timestamp? Write a markdown file that says so.

• Want it to always explain what it’s about to do before doing it? Another markdown file.

• Voice transcription with ffmpeg and Whisper? Describe the workflow in markdown and the model executes it.

No integration code, no new tool definitions. It’s natural language instructions that become part of the agent’s behavior. This is exactly how production agent systems like Claude Code handle capabilities. The “skills” on disk are markdown files the model reads at the start of every conversation.

Also, there’s a module on GitHub on extending for longer running tasks for a Ralph Loop. This in short externalizes the messages in context to a file that can be read into different sessions. More here.

We ended on discussing security with Civic

With agent loops being able to control a computer and read files, it’s easy for things to go wrong:

• Prompt poisoning, when an agent reads a website or message with malicious text inserted

• Authorization management, when starting to connect an agent to other tools, like Gmail or Slack

• Guardrails, ensuring that the agent is not doing anything it’s not supposed to

Titus Capilnean from Civic Technologies showed how they help act as a layer between an agent and managed authorizations through their MCP server. Every kind of agent, from Claude Code to OpenClaw can use Civic. More here.

Here’s the tl;dr

1. Every AI coding agent — Claude Code, Cursor, Devin, Codex, OpenClaw — runs a version of the same loop: send messages to a model, check if it wants to use a tool or respond with text, feed results back, repeat until it breaks.

2. AI models are stateless, like waking up with amnesia. Every time you call the API, you send the entire conversation history from scratch. The messages array is the memory, and you maintain it yourself.
3. Tool calling is what turns a chatbot into an agent. Instead of parsing free text and hoping the model listened, it uses a structured protocol to signal "run this command" versus "here's my answer."

4. You can extend an agent's capabilities by dropping a markdown file into a folder. No code changes. Skills are just natural language instructions the model reads and follows.

5. When a task outgrows a single conversation, externalize state to files and loop in short iterations so the model never accumulates enough stale context to lose track of the goal.

Thank you to our partners and co-hosts

• Will Sentance for leading the workshop, including everyone, and enabling this kind of understanding for people with all backgrounds

• Titus Capilnean and Nancy Li for the support and sharing important security considerations when working with agents

• Nate Padgett and Studio 45 for the physical space for these kinds of workshops to happen

See you at the next build!

Hi I’m Michael, Founder of Worldwide Studios, where we help people build with the latest AI tools, hardware, and applied sciences. From 2hr intros like this one to 100 day fellowships, we help people make sense of how things are changing to solve real problems.

Hi Everyone,

We hosted a 100+ AI for Science Cell Cultivation Hack in SF this weekend with Monomer, Cephla, Opentrons and more. It’s crazy what small teams can build in 24hrs. Multiple teams did 3 experiments end to end with AI agents in the loop on robotic workcell. One team had an OpenClaw update protocols from an Uber. Another made a conversational interface with a robot. ICYMI here’s the full recap.

Upcoming Workshops

1. AI Agents for MBAs: Data Analysis in Google Opal

   Tues ∙ March 24 ∙ 4:00p-5:00p PT ∙ Virtual ∙ Ticketed

   ​Build your first (or next) agent in Google Opal. We’ll go over adding datasets in context and run code execution node where you can run scripts.
   Learn more and sign up here →
   

2. AI Agents for Founders: Data Analysis in Claude Code

   Tues ∙ March 24 ∙5:30p-6:30p PT ∙Virtual ∙ Ticketed

   Design your first (or next) workflow in Claude Code by reading and loading files locally to run different analyses.
   Learn more and sign up here →

3. 3. AI Agents for Full Stack Web Dev: Deploy with Vercel and Claude Code

   Fri · March 27 · 10-11a PT · Virtual · Ticketed

   Start with your first customer in mind and build your minimum testable prototype with Claude Code, deployed on Vercel.

   Learn more and sign up here →

Build Guides and Blogs

• AI Agents for MBAs: Investment Memos in Google Opal (Blog and template here)

• Intro to Google Opal (Blog and video here)

• Intro to Claude Code (Blog and video here)

More community events ahead

Workshops

• AI Agents for MBAs: Custom Presentation Slides in Google Opal (April 7)

• AI Agents for Founders: Custom Slides with Agent Skills in Claude Code (April 7)

• AI Agents for Builders: Full Stack Web Dev Supabase for DB and Auth with Claude Code (April 10)

Community events

• AI + Health Demo Night #10 @ level (SF, March 26)

• AI for Good: Future of Education with OpenClaw (SF, March 28)

• Open Build Night: OpenClaw in 20 lines of Code (SF, April 2)

• AI for Science Summit in SF (SF, June 16-17)
  

Keep building,

Michael

Founder 🌐 Worldwide Studios

Ps. We’re running 2hr AI agent build along workshops for teams and communities, like this one for MIT Sloan Alumni. If you want to see one for your role or your team, reply back as we’re designing these with community members for specific use cases.

Hi Everyone,

This week we open sourced Skilltrees, a product experiment exploring what the Cursor for learning could look like. It generates custom learning playlists on any topic. More info here in the blog announcement.

We’re starting to publish some build guides based on the workshops we’re hosting. Check out intro to Google Opal, Claude Code, and an investor memo agent template below.

Upcoming Workshops

1. AI Agents for Builders: Full Stack Web Dev First Prototype with Claude Code

   Friday ∙ March 13 ∙ 10a-11a PT ∙ Virtual ∙ Ticketed

   Start with your first user (or customer) in mind and build your minimum testable prototype in Claude Code.
   Learn more and sign up here →
   

2. AI Agents for MBAs: Data Analysis in Google Opal

   Tues ∙ March 24 ∙ 4:00p-5:00p PT ∙ Virtual ∙ Ticketed

   ​Build your first (or next) agent in Google Opal. We’ll go over adding datasets in context and run code execution node where you can run scripts.
   Learn more and sign up here →
   

3. AI Agents for Founders: Data Analysis in Claude Code

   Tues ∙ March 24 ∙5:30p-6:30p PT ∙Virtual ∙ Ticketed

   Design your first (or next) workflow in Claude Code by reading and loading files locally to run different analyses.
   Learn more and sign up here →

Build Guides and Blogs

• Skilltrees.ai Open Source Release (Blog and GitHub Repo Here)

• Intro to Google Opal (Blog and video here)

• Intro to Claude Code (Blog and video here)

More community events ahead

Workshops

• AI Agents for Builders: Full Stack Web Dev Deploy with Vercel and Claude Code (March 24)

• AI Agents for MBAs: Custom Presentation Slides in Google Opal (April 7)

• AI Agents for Founders: Custom Slides with Agent Skills in Claude Code (April 7)

• AI Agents for Builders: Full Stack Web Dev Supabase for DB and Auth with Claude Code (April 10)

Community events

• Personal Lindy AI Assistants @ Lindy HQ (SF, March 12)

• 5th AI for Science Hack Cell Cultivation @ Monomer Bio (SF, March 14-15)

• We’ll be giving a product talk at NYU’s Flourishing in Age of AI Summit (NY, March 18)

• Open Build Night: OpenClaw in 20 lines of Code (SF, April 2)

• AI for Science Summit in SF (SF, June 16-17)
  

Keep building,

Michael

Founder 🌐 Worldwide Studios

Ps. We’re running 2hr AI agent build along workshops for teams and communities, like this one for MIT Sloan Alumni. If you want to see one for your role or your team, reply back as we’re designing these with community members for specific use cases.

1. Chat interfaces are probabilistic and limited by their built-in tools, making them suboptimal for complex tasks. Custom AI agents enable more deterministic, step-by-step workflows with specific tool calling at each stage

2. Breaking a task into discrete steps (plan → research → write) gets better results than asking an LLM to do everything at once. Multi-step agent workflow outperformed Claude Opus 4.6 extended thinking in a zero-shot memo test

3. Prompt tips for agent nodes: use hierarchical formatting (markdown), assign specific roles, and define what success looks like

4. Google, Claude, and ChatGPT each have different strengths (multimodal, connectors, speed) — none is best at everything

5. LLM-as-judge is a useful eval pattern: score memos on overall quality, copy, data-driven insights, and unique take

6. Future improvements include adding citations, self-eval loops, multimodal outputs, pitch deck inputs, and deeper data analysis nodes

I tested writing an investment memo five different ways, from zero-shot prompting in Claude Opus 4.6 with extended thinking to a multi-step agent workflow in Google Opal. The agent won.

The multi-step workflow made a better analysis, had more data-driven insights, and a more opinionated take than the best chat interface on the market could generate in a single pass. Here’s why that matters and how to build your own with a template included.

The Problem with Chat for Complex Workflows

Chat interfaces are doing too many things at once. When you ask Claude or Gemini to “write me an investment memo on Physical Intelligence,”1 the model is simultaneously figuring out how to approach it, deciding what to research, calling tools, and synthesizing a response. That’s a lot of inferred process in one pass.

It’s also probabilistic. Each run can use different tools, take different paths, and produce varying results. And it can be limiting to whatever tools that specific chat app offers. Google has strong multimodal but weaker connectors. Claude has great connectors but no multimodal output. ChatGPT is trying to do everything. They each have different baselines for intelligence, costs, and speed. More here.

Custom agents solve both problems. Defined the steps. Tool selection at each step. The workflow becomes more deterministic, more reliable, and, more importantly, better at each individual task because no single node is trying to do everything.

Why Discrete Steps Get Better Results

Think of the writing process. Nobody sits down and produces a polished memo from a blank page in one pass. First, start with a plan, then research, and then write. Agents work the same way.

This diagram, inspired by Zapier, shows the spectrum of full deterministic automations v. full inference led automations with AI agents.

1. Automating workflows: full determinism with each step called out

2. Agentic workflows: AI nodes embedded within a step by step process

3. AI Agent: AI agent determines each step and tool all to get outcome

So we’ll work to use the best of both: step by step support and embedding AI nodes in the process. This enables more control over the results and more reliability than either one alone. And if you’re new to Google Opal, you can read more here.

My best-performing workflow had three stages:

• Plan (outline the memo structure and research directions),

• Research (enrich each section with data),

• Write (synthesize into a final draft).

Each stage handed off context to the next.

Why this works: the planning node can focus entirely on thinking through what a great memo needs. The research node doesn’t have to worry about structure. It focuses on data gathering and research. The writing node receives a rich brief instead of starting cold. It’s the same reason a chef preps ingredients before cooking.

I tested five approaches head to head.2 Zero-shot in Opus 4.6 extended thinking was my baseline. The multi-step agent — using Gemini 3.1 Pro with better prompts at each node — outperformed it across overall quality, specificity of copy, data-driven insights, and originality of take.

👉 Google Opal template.

📝 Sample output memo (in footnotes)3

👩‍⚖️ Eval template with LLM as a judge.4

How to Prompt Agent Nodes Well

Prompting inside an agent is different from chatting. You’re writing instructions for a specific task within a larger workflow, not having a conversation.

Three things that make the biggest difference5:

1. Make information hierarchical.
   Use markdown. Headers signal priority. # Role matters more than ## Guidelines. Number your lists. Nest details under sections. The model reads structure as meaning.

2. Assign a specific role.
   “You are a startup investor” gets generic output. “You are a General Partner at a $300M deep tech fund evaluating first-round deals, high tech risk tolerance, low market risk tolerance” unlocks a different part of the embedding space. The more specific the role, the more specific the output.

3. Define what success looks like.
   Either describe it (”Ask the hardest questions for each section to ensure a more holistic view”) or show it (include an example memo you like as a one-shot). The model can’t hit a target it can’t see.

For example, here’s the planning node that worked best for me

Here’s the planning node prompt that worked best for me:

# Role
You are a General Partner at Khosla Fund who plans thoughtful investment memos that are data driven and persuasive.

# Task
Write an outline plan for investment memo research for {{company name}}.

Sections:
1. Executive Summary
2. Founding Team
3. Problem
4. Solution
5. Market Opportunity (TAM)
6. Business Model
7. Competition
8. Diligence Questions.

# Guidelines
1) Each section should include data-driven research directions.
2) Specify what to search for and why.

This can be updated with more specific context and direction to best fit what you want to use this template for.

Making this agent better

This workflow is a starting point, like an initial recipe.

Some ideas for improvements:

• Pitch deck as input. For memo writing, many teams will have a deck on hand to start the research process. You can use upload file as an input node to kickoff the research workflow.

• Multi-modal. Add images, audio, and/or video as part of the

• Explore more robust research and analysis. Specific nodes for specific parts of the memo, especially for richer data analysis and modeling, like revenue or market forecasting.

• Specific outputs. We kept it text for ease of eval. You can explore Google Docs, Slides, or even custom HTML pages.

• Citations. Getting the writing step to have citations.

Try out the memo template. Try out the evaluation LLM as a judge template.
And from there, start tinkering and changing things to make it your own.

If you have ideas, comments, or questions, add them below.
We treat the comments like NYT recipes comment where people share ideas and best practices.

Made with curiosity by 🌐 Worldwide Studios, a 501c3 CA non-profit hosting AI workshops and hacks.

📆 Check out the full calendar here to join for a future AI workshop.

Footnotes

2

Here’s the data and resulting memos from initial testing

4

Google Opal Template: LLM as a Judge

With AI enabled workflows enabling more output, it’s important to have systems in place to check the quality and accuracy of the work. Here’s the LLM as a judge template used to compare each Opal output to the Claude Opus memo for Physical Intelligence.

Here’s the prompt

# Task

Evaluate these investment memos

x/10 - Overall Memo

x/10 - Copy (is it specific, direct, easy to read)

x/10 - Data (data driven insights in each section)

x/10 - Unique take (interesting opinion)

# Memos
1. Claude Opus 4.6 Prompt (paste in)

2. New memo (add in)

5

We’re working on an AI tutor to help get feedback on prompts for agents and in platforms

We built an AI tutor that will help you dial in your prompts for each step of the workflow. It loads specific challenges, like for this Google Opal flow, and gives feedback at each step.

This is currently in private beta testing.

If you want to try the prompt tutor, you can explore an upcoming workshop with live testing.

tl’dr

• Claude Code isn’t only a coding tool. It’s a general-purpose AI agent that happens to write code and can automate research, writing, tasks, and more.

• Install it, open your terminal, type “claude,” and spend most of your time in Plan Mode when writing code to get the instructions right before letting it act.

• Connect it to your existing tools (email, calendar, Notion, GitHub) through MCPs to make it actually useful for your daily workflow.

• Build context gradually. every time you explain something to Claude twice, save it as a file so you never have to again.

• The real skill isn’t prompting. It’s looking at every task you do and asking “how can I delegate or automate this with Claude?”

Intro

Hello!

This is a 10min warm up guide to help you prep for AI Agents for Founders: Personalized Research Memo, where we’ll be building an executive assistant.

Main action items before the session:

[ ] Make sure you have access to Claude Code in your terminal. Install instructions here.

[ ] Watch the video above and read through the guide.

[ ] Come prepped with any questions you have.

Questions? Reply in comments below or send a note over.

About Claude Code

Claude code is a misnomer. It’s more like Claude-general-agent-that-happens-to-write-code-and-can-do-other-kind-of-work-for-you.

There are 7 ways to access Claude Code.

Anthropic’s Claude models have been popular with the engineers, scientists, and builders we’ve supported over the last couple of years. It’s more recently gotten attention since:

1. Opus 4.5 was released in Nov 2025, making it smarter and better

2. People realized Claude Code could be used for more than just coding

Claude Code is different than a chat app (claude.ai) because it can write and read code as well as access local files.

There are different ways to access Claude Code:

1. Terminal CLI, the OG way of using Claude Code

2. In your IDE of choice: VS Code, Cursor, Antigravity

3. Desktop App: Co-work is a light bridge between Claude (the chat), and Claude Code (the coding agent)

4. Web/Mobile App now has Claude Code session support

5. GitHub Actions

6. Slack App

7. Chrome App

You can also build your own agent with Claude Code Agent SDK.

We recommend 1+2 because it’s the most powerful way to use all of the features of Claude Code at this time. The team is constantly shipping features, and so 3-7 are getting better every single week.

Install Claude

For support installing Claude Code, check out Anthropic’s official guide. And if you have trouble you can ask Claude.ai on web to ask questions.

Note, to use Claude Code you will need a Pro/Max subscription, or an API key.

Once installed, you type in the wake up word, “claude,” and that starts a session with Claude Code. You can also use the terminal access in IDE.

There are three main modes for Claude Code

When you hit Shift+Tab you update the mode for Claude Code:

1. Plan Mode = talking with Claude to plan updates. It will take no actions until the plan is set. 70-80% of the work with Claude Code can be in plan mode to get things right.

2. Ask permission = Claude will ask for permission for every update and change.

3. Accept Edits = Claude Code has permission to make most changes, and will ask for permission for new tool use.

Claude Code operates in the command line and uses tools like: grep, bash, ls, glob, fetch.

1. Grep — Searches inside files for specific text or code patterns. Like Ctrl+F but across your entire project. “Find every file that mentions user_auth.”

2. Bash — Runs terminal commands directly. Anything you’d type in your shell — git commit, npm install, python test.py — Claude can run it too.

3. LS — Lists what’s in a folder. Claude uses this to orient itself and understand your project structure before diving in.

4. Glob — Finds files by name or pattern. Where Grep looks inside files, Glob finds files themselves. “Show me every .tsx file in the components folder.”

5. Fetch — Pulls content from the web. Claude can grab documentation pages, API references, or any URL mid-session so it doesn’t have to guess.

The command line interface is a text based window to control your computer. Everything you can do with the graphic interface, like creating new files or moving folders around, you can do through the command line. With Claude Code being powered by a Large Language Model, a text based interface is good for it.

If you’re new to the command line, try some of these to get familiar with it even before waking up Claude in a session:

• ls — List what’s here. Type ls and hit enter to see all the files and folders in your current location. It’s like opening a folder on your desktop.

• cd — Change directory (move around). cd Documents moves you into the Documents folder. cd .. moves you back up one level. It’s how you navigate without clicking.

• pwd — Print working directory. If you ever feel lost, type pwd and it tells you exactly where you are in your file system. Think of it as “where am I right now?”

• mkdir — Make a new folder. mkdir my-project creates a folder called “my-project” right where you’re standing. That’s it — you just made something from the command line.

• cat — Read a file without opening it. cat readme.txt prints the contents of that file right in your terminal. Quick way to peek at what’s inside something.

Connect Claude Code to other software and data

What makes Claude Code powerful is it’s ability to connect to almost any software and almost any data. If there’s an API, then you can use Claude Code to access it. If there’s MCP or Agent Browser compatibility, even better.

Quick peak to more advanced parts of Claude

1. Connectors/MCPs allow Claude Code to connect to your email, calendar, GitHub, Notion and hundreds of other tools. More here.

2. MCP Interfaces are tools that have widgets enabled in Claude.ai web chats. You can design your own interfaces when working with Claude Code locally.

3. Skills.md enables Claude Code to have specific recipes and knowledge for your workflows. They are composable, meaning you can combine them, and have progressive disclosure, so as not to clog your context. npx skills by vercel has a bunch you can check out.

4. Hooks enable you to run certain events automatically. Scheduled tasks are new, and enable you to schedule certain sessions in Claude Code.

5. Plugins are a combination of MCPs, hooks, and skills for additional use cases. Anthropic has official plugins here. Or if you’re in Claude Code, type /plugins to see the list.

This is important: If you ever get stuck or need help with ideas, you can describe what you are trying to do and have Claude figure it out with you.

See what people have built with Claude Code, with the winners of the Opus 4.6 hack

One interesting thing about this hack is it showed the professionals of all different backgrounds can build. Mike B. is an attorney and Michael N. is a cardiologist. Full list of projects and video pitches here on X.

1. Mike Brown built CrossBeam to speed up California's permitting process by giving builders and municipalities faster tools for code compliance and plan review.

2. Jon McBee built a visual programming environment for kids where you snap blocks together and Claude spins up agents to build the real code behind the scenes. The first user: his 12-year-old daughter.

3. Michal Nedoszytko, a cardiologist, built Postvisit to turn visit transcripts and medical records into ongoing, personalized health guidance. Patients leave doctor’s offices every day without understanding their diagnosis.

4. Asep Bagja Priandana built Conductr to play chords on a MIDI controller and Claude follows along, directing a four-track generative band around you.

5. Kyeyune Kazibwe built TARA, a dashcam-to-economic-appraisal pipeline that turns road footage into infrastructure investment recommendations.

More resources and examples of personalOS from founders

• Boris Cherny on Lenny’s Podcast (1.5hr)
  Boris Cherny, the creator of Claude Code, talks about how it went from a quick terminal hack to powering 4% of public GitHub commits and why he believes coding is essentially “solved.” He shares practical tips for getting the most out of Claude Code and Cowork, plus his thinking on what professional work looks like once AI handles the building.

• Full Tutorial: Build an AI Life Co-Pilot with Claude Code in 25 Minutes | Alex Finn
  Alex Finn walks through “Claude Life,” his personal operating system built entirely with Claude Code slash commands and sub-agents including a newsletter researcher that drafts his weekly Substack to a daily news briefer and brain dump analyzer that surfaces content ideas. The big takeaway: Claude Code is really just a general-purpose AI agent, and the skill to build is asking “how can I automate this?” for every task you do throughout your day.

• Full Tutorial: Build Your Personal OS with Claude Code in 50 Min | Teresa Torres
  Teresa Torres, author of Continuous Discovery Habits, walks through how she uses Claude Code as a digital coworking partner for everything: a daily task system, collaborative blog writing (9,000 words in 1.5 days), SEO research, and a three-layer context system that teaches Claude about her business without crowding the context window. Her core advice: treat Claude like a new digital coworker you’re delegating to, build context files gradually instead of all at once, and ask yourself every time you explain something to Claude, “Will I have to explain this again?” if yes, save it.

• Chief of Staff with Claude Code
  An overview of how someone has set up context and multiple agents for personal workflows, like email checker and time boxer. They have a non-technical background and use Claude Code Max plan.

If you have comments, questions, or ideas, comment below!

Made with curiosity by 🌐 Worldwide Studios, a 501c3 CA non-profit hosting AI workshops and hacks.

📆 Check out the full calendar here to join for a future AI workshop.

Last year we worked on different proof of concepts for various forms of AI native learning. This month we’re open sourcing one of them: Skilltrees AI.

Skilltrees AI

With skilltrees we wanted to do three things:

1. Project based learning,

2. Tailor it to a users specific need

3. Make it feel like playing a video game.

We achieved this in its first prototype form by having an AI assistant onboarding flow to gather what you want to learn, for what purpose, and then, we generate a tailored path to learning the thing and accomplishing the goal.

All of this is displayed on a canvas with a feel similar to a real time strategy game. It has a skills coach through chatbot experience, supplemental Youtube videos, and an AI that tests you for each skill.

Onboarding

The process starts by getting a blurb about what you want to learn and generating some basic questions for you to answer

You can really tailor things to your specific needs, some trees we’ve seen or tested

• Creating and marketing a microbrand bakery

• Machine learning for hardware engineers

• Develop lucid dreaming to explore your own subconscious

• Trace the philosophical lineage of Existentialism from Kierkegaard to Sartre

Get up and running

• Make sure you have docker, python, poetry and node/npm installed

• clone the github repo

• copy the .env.example to a new .env and fill out values

• run npm run setup which will automatically setup docker containers, install dependencies and run the platform for you!

• navigate to http://localhost:3000 and start the flow!

See GitHub

Some ideas for next set of features

We’re open sourcing these projects so more people explore the question: “What does AI-native learning tools look like?”

After getting the first set of user feedback, here are some ideas to continue to build on Skilltrees:

1. Make the canvas more intuitive. People wanted the titles and destinations to read more like a world map, step by step, than an abstracted constellation.

2. Progress state: grayed if not clicked, yellow if in progress, and green if completed.

3. Update action items and AI review for each action items. As this was a proof of concept, we focused on the overall interaction between each part of the prototype. We got feedback that the action items can be more specific and better tailored for what an individual wants.

If you have ideas, questions or comments, share below.

Made with curiosity by 🌐 Worldwide Studios, a 501c3 CA non-profit building AI-first products for learning.

We just launched our first AI in education fellowship for more open source builds. Read the announcement here.

tl’dr

• Google Opal is a visual, no-code AI app builder — drag-and-drop nodes for inputs, AI generation, and outputs, all connected in a flow diagram.

• It runs on Gemini’s full model lineup — from Gemini 3 Flash for simple tasks to Agents that can reason and take multiple steps, plus image (Nano Banana), video (Veo), and audio (AudioLM, Lyria 2) generation.

• Outputs go straight into Google’s ecosystem — save directly to Docs, Slides, or Sheets, or publish as an auto-layout webpage.

• Every Opal is shareable as a web app — with permission controls just like Google Docs, including a “remix” option so others can build on your flow.

• The workshop uses Opal to build an AI research agent for investment memos — come with access to opal.google and any questions you have.

Intro

Hello!

This is a 10min warm up guide to help you prep for AI Agents for MBAs: Investment Memos in Google Opal, where we’ll be building an AI research agent for investment memos.

Main action items before the session:

[ ] Make sure you have access to Google Opal.

[ ] Watch the video above and read through the guide.

[ ] Come prepped with any questions you have.

Questions? Reply in comments below or send a note over.

About Google Opal

To make sure you have access to Google Opal, go to: opal.google.

You should see this screen below. This is a list of all of your Opals.

We’re using Google Opal because it’s easy to use, shareable, and built on Gemini

Google Opal a visual, no code AI app builder that enables sharing, so anyone on your team can use what you build. The visual canvas enables different nodes to connect for a specific workflow, exchange context, and have custom prompts.

It’s easy to use because everything is drag and drop.

The flow diagram style shows exactly what’s happening from node to node. You select the nodes, connect them, and design your own flow.

There are different kinds of nodes:

1. User input nodes that you can have the user fill in information, like a form in the workflow

2. Generate nodes which are AI enabled using Google’s full line up of Gemini Tools. Different Generate nodes include:

   • Agent — This is an AI agent loop that can reason and take multiple action steps

   • Gemini 3 Flash — A single LLM call best for simple, everyday tasks

   • Gemini 3.1 Pro — A single LLM call for more complex tasks that require more reasoning

   • Nano Banana — For image editing and generation

   • Nano Banana Pro — For complex visuals with text

   • AudioLM — Generates speech from text

   • Veo — Generates videos from text and images

   • Lyria 2 — Generates instrumental music from text

Each generate node also has a set of tools that can be added in, like Get Weather, Search Web, Get Webpage, Search Maps, Code Execution, Use Memory, as well as call other context from other steps.

3. Output nodes create some kind of shareable output from the workflow.

   • Manual layout — Content is displayed exactly as typed.

   • Webpage with auto-layout — Layout automatically generated by Gemini

   • Save to Google Docs — Save content to a Google Document

   • Save to Google Slides — Save content as a Google Drive Presentation

   • Save to Google Sheets — Save content as a Google Drive Spreadsheet

4. Add Assets enables adding in additional multimodal context for a workflow.

   • Upload file allows you to add any file from your system.

   • My Drive brings in and loads any file from Google Drive.

   • NotebookLM calls a Notebook you made with NotebookLM.

   • YouTube enables any YouTube video to be brought into the workflow.

   • Text is extra text.

   • Drawing is a drawing to be used, like when generating images.

Each Opal is shareable as a web app link, making it easy to collaborate with others.

Just like you can manage permissions with a Google Doc in Google Drive, you can manage sharing permissions with Google Opal.

You can share access for people to use an Opal, like a web application.

You can also give people remix permission, meaning they can build on top of the flow you shared.

It has the latest Gemini models.

With Google Opal being a product of Google Labs, there is only access to Gemini’s latest models and Gemini API tools, including Gemini 3.1 Pro and Nano Banana for image generation.

With Gemini’s models getting better and companies starting to have Enterprise access, this can be an upside for some people, especially in a team setting.

One interesting API example is the Code Execution tool. You can have scripts run in specific nodes for data analysis.

If you are looking for more model provider and tool flexibility, then other tools like Gumloop or Lindy may be better.

Some examples of Opals

Opal has a link to it’s own recommended templates to help you get started. That includes:

1. Book Recs — Get book recommendations and discover your next favorite read

2. Business Profiler — A glimpse into how the internet sees your business

3. Claymation Explainer — Turn any topic into an animated claymation infographic

4. Co-Thinker — Puts on a thinking hat and helps you better understand a problem

5. Create a Playlist — Create a mood playlist with YouTube links

On the home page scroll down to the templates section to see.

tl’dr

• Google Opal is a visual, no-code AI app builder — drag-and-drop nodes for inputs, AI generation, and outputs, all connected in a flow diagram.

• It runs on Gemini’s full model lineup — from Gemini 3 Flash for simple tasks to Agents that can reason and take multiple steps, plus image (Nano Banana), video (Veo), and audio (AudioLM, Lyria 2) generation.

• Outputs go straight into Google’s ecosystem — save directly to Docs, Slides, or Sheets, or publish as an auto-layout webpage.

• Every Opal is shareable as a web app — with permission controls just like Google Docs, including a “remix” option so others can build on your flow.

• The workshop uses Opal to build an AI research agent for investment memos — come with access to opal.google and any questions you have.

Made with curiosity by 🌐 Worldwide Studios, a 501c3 CA non-profit hosting AI workshops and hacks.

📆 Check out the full calendar here to join for a future AI workshop.

Hi Everyone,

This week we launched our first AI in Education Worldwide Venture Fellowship. We’ll have a cohort from all different backgrounds, including AI engineering, product, alt schools, accreditation, neuroscience, and more, all building towards new AI-native solutions. Launch announcement here in case you missed it.

This next month, we’ll be running role specific workshops. AI Agents for MBAs, founders, and builders. Come join one to build something new and jam on the latest in AI.

Featured Workshops

1. AI Agents for MBAs: Investment Memos in Google Opal

   Tues ∙March 10 ∙4-5p PT ∙Virtual ∙ Ticketed

   Come join to make your first (or next) AI Agent in Google Opal, an experiment platform from the Google Labs team. We’ll be covering investment memos.
   Learn more and sign up here →
   

2. AI Agents for Founders: Personalized Research Memos with Agent.MD in Claude Code

   Tues ∙March 10 ∙530p-6:30p PT ∙Virtual ∙ Ticketed

   ​Build your first (or next) agent for Claude Code. We’ll cover how to set up a general personal assistant with a custom Agent.MD and ability to do research memos for customer and client research, market competition, and exploring different topics.
   Learn more and sign up here →
   

3. AI Agents for Builders: Full Stack Web Dev First Prototype with Claude Code

   Friday ∙March 13 ∙10a-11a PT ∙Virtual ∙ Ticketed

   Start with your first user (or customer) in mind and build your minimum testable prototype in Claude Code.
   Learn more and sign up here →

More community events ahead

Workshops

• AI Agents for MBAs: Data Analysis in Google Opal (March 24)

• AI Agents for Founders: Data Analysis in Claude Code (March 24)

• AI Agents for Builders: Full Stack Web Dev Deploy with Vercel and Claude Code (March 24)

• AI Agents for MBAs: Custom Presentation Slides in Google Opal (April 7)

• AI Agents for Founders: Custom Slides with Agent Skills in Claude Code (April 7)

• AI Agents for Builders: Full Stack Web Dev Supabase for DB and Auth with Claude Code (April 10)

Community events

• Personal Lindy AI Assistants @ Lindy HQ (SF, March 12)

• 5th AI for Science Hack Cell Cultivation @ Monomer Bio (SF, March 14-15)

• We’ll be giving a product talk at NYU’s Flourishing in Age of AI Summit (NY, March 18)

• Open Build Night: OpenClaw in 20 lines of Code (SF, April 2)

• AI for Science Summit in SF (SF, June 16-17)
  

Keep building,

Michael

Founder 🌐 Worldwide Studios

Ps. We’re running 2hr AI agent build along workshops for teams and communities, like this one for MIT Sloan Alumni. If you want to see one for your role or your team, reply back as we’re designing these with community members for specific use cases.

Open AI’s first API came out in 2023. By now, there should be $10/mo engineering tutor with MIT level open courseware support to speed run PhD level topics with morning coffee.

Or the Cursor for learning with a platform experience with great memory and context management for exploring any topic. Neither of those exist yet. At least, not at scale to our knowledge.

There’s been a lot of progress in other industries and applications:

• codegen with Codex, Devin and Claude Code,

• design with Variant, Figma Make,

• and even legal with Harvey AI and health, Open Evidence and Abridge.

Not enough in education.

Yet, there’s so much potential in unlocking the latest models of education with the latest AI tools.

So we launched a venture fellowship to accelerate new solutions today to yesterday’s age old problems. From K12 personal tutors to new live assessments for hiring, fellows will explore and build their own ideas in small teams.

100 days. Weekly progress. From idea to real impact with first pilots.

Here are the fellows

• Jeremiah ‘Jay’ Johnson is an AI native storyteller and educator who helps run global workshops for teams.

• Vedansh Mannem started a math tutoring non-profit and is now exploring new AI tools, like an SAT question generator for practice tests.

• Xiangan He runs a dev shop that’s worked with clients like Google, State Street, and YC-backed startups. He’s building what he wish he had in early education.

• Barbara Jauregui Wurst founded an Acton Academy alternative school in the DC area inspired by her own kids’ love of learning. She wants to see new tools for young people to thrive.

• Lilian Gong is a learning engineering researcher at ASU who built a French tutor bot using a multi-agent LLM system. She’s exploring alternatives way to cultivate and assess skills and knowledge outside of trad homework.

• Oleksandra ‘Sasha’ Pariy is a CEO and product builder. She’s built a vector embedding database for a professor to let students chat with large PDFs and get accurate citations.

• Scott Nicoll has 10+ years teaching critical thinking in Asia, now exploring a contrarian tutor to help cultivate self awareness and independent thinking.

• Feodor is in Saint Petersburg building a startup community at ITMO and exploring global education opportunities.

• Ryan Leong has experience across startups in underwater robotics and real estate and is now exploring ways to increase AI literacy for young people.

• Harsh Thakkar is in an applied global program in Accra, Ghana, partnering with public school teachers to design hands-on learning models.

• Michael Davola runs tech staff development at a public school on Long Island in New York. He built a self-reflection coach in video form to help students make video journal entries.

• Maruthi Vemula built an adaptive system to figure out what to learn next, moving away from fixed curriculums.

• Morgan Hough is a researcher focused on computational psychiatry and cerebral organoids. He explored Zuna, a brain foundation model using EEG data.

• Joseph Ching is a Higher Education Program Manager who wants to build AI literacy for current students and explore new models for accreditation.

• Jasjeev Singh has been working on ways to support neuro-developmental care and education. He built a children’s game for families around learning styles.

And if you have a community or a school that wants to try out the latest tools that get built, reach out.

Worldwide Studios is a CA 501c3 education non-profit helping professionals build with the latest in AI, hardware, and applied sciences.

Hi Everyone,

People have enjoyed the new feature Fridays for Claude Code, so we’ll keep those up. Also, below a recap from the AI + Education hack in SF this past weekend: rork.com is a fun new tool to build with! Teams built full mobile applications in 25min with a few prompts.

Highlights for what’s coming up

1. New Feature for Claude Code: Previews for Front End (Friday, 10a PT, Virtual)

   We’re exploring the latest feature for Claude Code: Previews, which helps test front end designs in the desktop app.
   

2. AI Tutor: Build an AI Web App with Claude Code, Vercel, + Supabase (Sat 10a PT, Virtual, Ticketed)

   We got really good feedback on last week’s AI Tutor, and working to help people make their first full stack AI enabled web app in this 2hr workshop.
   

3. In case you missed it, guides + recordings

• AI for Education Build Recap

• 50 Project Ideas for YC’s Request for Startups Spring 2026
  

Coming up

• 5th AI for Science Hack Cell Cultivation @ Monomer Bio (March 14-15)

• We’ll be giving a product talk at NYU’s Flourishing in Age of AI Summit (March 18)

• AI for Science Summit in SF (SF, June 16-17)
  

Keep building,

Michael

Founder 🌐 Worldwide Studios

Ps. We’re running 2hr AI agent build along workshops for teams and communities, like this one for MIT Sloan Alumni. If you want to see one for your role or your team, reply back as we’re designing these with community members for specific use cases.

This isn’t a reading list. It’s a building list.

Whether you’re prepping for SPC, going through a fellowship, running a hackathon, or just trying to figure out what to work on next, the fastest way to develop conviction on a problem is to get your hands dirty with the existing open source tools in that space. You’ll learn more in a weekend of building than a month of reading blog posts.

Here’s how to use this:

If you have a weekend, pick a Level 1 project from any topic that interests you. Clone it. Run it. Break it. You’ll know within 48 hours whether this problem space excites you.

If you have a month, go deep on one topic. Start at Level 1, work your way to Level 3. By the end, you’ll have a portfolio artifact and a real opinion on what’s missing in the space.

If you’re exploring a startup idea, the Level 4 and 5 projects represent genuine infrastructure gaps. If you find yourself building custom solutions at those levels because nothing good exists, you might be sitting on a company.

The 12 Questions SPC Wants Founders Exploring Right Now

Before we get into the projects, here are the questions straight from SPC’s list. If even one of these piques your interest, keep reading.

The projects that follow are how you start approaching the question with first steps.

1. What if scientific knowledge was no longer codified in published papers?

2. What new business models are lurking around the corner?

3. What are the new form factors on which humans will spend their attention?

4. How do we bring AI to the next billion people?

5. What kinds of hardware and software advances will make AI compute more scalable and sustainable?

6. What if we make machine learning continuous and distributed?

7. How will we adapt to the growing attack surface created by ubiquitous data capture and the malicious use of AI?

8. What if we could program the physical world as fluidly as we program software?

9. How will AI inspire new telemetry: what we can perceive, measure, and understand about reality?

10. How can AI enable deeper human connection rather than replace it?

11. What new forms of governance will emerge from artificial intelligence and agentic economies?

12. How should we rethink institutions to support rapid onshoring of manufacturing and production across sectors?

Every one of these questions has open source tooling you can start building with today. Most people get stuck in the “researching the space” phase for months.

The fastest way to develop a real opinion is to build something, hit the walls, and discover what’s missing.

1. What if scientific knowledge was no longer trapped in PDFs?

SPC’s first question is about reinventing how science gets published, discussed, and synthesized. The journal system was revolutionary in 1665. It’s now the bottleneck. Peer review takes months. Knowledge is locked behind paywalls. And nobody can synthesize the 5 million papers published every year.

The open source ecosystem here is actually further along than most people realize. There are already tools that let AI read, write, and reason about scientific literature. The question is whether someone will stitch them together into something that replaces the journal.

1. Start quick. Paperlib is an AI powered academic paper manager. You can semantic search your library in natural language, chat with LLMs about your papers, and organize everything locally. Install it, load up 50 papers on a topic you care about, and start asking questions. You’ll immediately see both the power and the limitations.

2. Build something useful. Wire up the Semantic Scholar API with a RAG pipeline using LangChain. Build a literature review bot that pulls papers, identifies contradictions between findings, and generates testable hypotheses. This is genuinely useful for any researcher and takes about a week to get working well.

3. Get ambitious. Sakana AI’s The AI Scientist is the first fully autonomous research system. It generates ideas, writes code, runs experiments, and drafts papers. Fork it and scope it to a specific domain. See what happens when you point it at a problem you actually care about.

4. Build infrastructure. Manubot is a platform for “living papers” with version control, continuous integration, and multi-author attribution. The idea of a paper that updates in real time, with threaded discussion and proper attribution, is exactly what SPC is asking about. This needs someone to turn it from a research tool into a product.

5. Insane unlock. NovelSeek is a closed loop autonomous discovery system that goes from hypothesis to experiment to verification without human intervention. Combine it with lab automation (like Opentrons) and you’ve got the self-driving laboratory. This is a full startup if you can make it reliable.

2. What are the new business models for AI?

Every technology paradigm shift rewrites the economic playbook. The internet gave us ad supported marketplaces. Mobile gave us the gig economy. Cloud gave us SaaS. AI is going to give us something new, and the people who figure out what it is first will build the next generation of infrastructure companies.

SPC is asking specifically about selling “work” instead of software, monetizing without ads, and what happens when agents transact on behalf of people. These are existential questions for every software business.

6. Start quick. AgentPayy is a micro-payment protocol for AI agent API calls. Sub-cent crypto payments on Base L2. Install the SDK and you can monetize any API endpoint in an afternoon. It’s the simplest way to experience what “pay per action” economics actually feel like from the builder side.

7. Build something useful. LiteLLM is a unified API proxy for 100+ LLM providers with built-in usage tracking, billing, and rate limiting. Deploy it and start routing requests across providers. You’ll immediately understand token economics, margin structures, and why “selling intelligence on tap” requires completely different unit economics than SaaS.

8. Get ambitious. XPack.ai converts any OpenAPI spec into a monetizable MCP service with one click. Built-in Stripe billing, user management, and SEO pages. You can deploy your own AI tool marketplace in under 10 minutes. This is the “Shopify for AI services” play.

9. Build infrastructure. FinRobot is a multi-agent financial analysis platform. The interesting business model question here is outcome-based pricing: what if you charge based on the quality of the research report or the accuracy of the trading signal, not the number of API calls? Build it and find out.

10. Insane unlock. Fetch.ai’s uAgents framework enables fully decentralized agent-to-agent marketplaces. AI workers discover each other, negotiate terms, and transact autonomously. This is the infrastructure layer for an economy where most transactions happen between machines, not people. If that sounds crazy, remember that algorithmic trading already accounts for 60%+ of equity market volume.

3. How will people spend their attention when AI content is everywhere?

AI slop is already overwhelming every platform. The feed is drowning in generated content. SPC is asking: what comes after the feed? What are the new form factors that capture human attention when the old ones are polluted?

This is a design question as much as a technology question. The projects below range from content creation tools to full simulated social worlds.

11. Start quick. ComfyUI is a node-based visual workflow for AI content generation. Images, video, audio, all through a drag-and-drop interface. It’s the fastest way to understand what “AI native content creation” feels like and why traditional content tools are about to be disrupted.

12. Build something useful. Open Interpreter gives you a natural language interface to your entire computer. AI that sees your screen, clicks, types, and executes. It’s a prototype of what computing looks like when the primary interface is conversation, not windows and clicks.

13. Get ambitious. SillyTavern is an extensible AI character interaction platform with memory, personas, and world-building. It looks like a chat app but it’s really the open source foundation for AI native entertainment. The community has built surprisingly deep interactive experiences on top of it.

14. Build infrastructure. Stanford’s Generative Agents simulates AI NPCs with memory, reflection, and emergent social behavior. This is the research foundation for games where every character is a real AI with its own goals, relationships, and personality. The entertainment industry is watching this space closely.

15. Insane unlock. The world models frontier (tracked in repos like Awesome World Models) includes projects like GameGen-X that generate playable game environments in real time from text descriptions. Interactive, explorable AI generated worlds. This is where entertainment, simulation, and spatial computing converge.

4. How do you build AI products for people who don’t type in English?

OpenAI has nearly a billion users. But the next billion will interact with AI through voice, gestures, and images, not text prompts in English. They’ll be in geographies where internet is spotty, devices are low-powered, and their language might not have much representation in training data.

This is one of the most important and most underserved areas in AI right now.

16. Start quick. OpenVoice does instant voice cloning from a 6 second sample across multiple languages. It’s MIT licensed and runs on modest hardware. Build a voice-first AI interface for a non-English language in an afternoon and you’ll immediately see both the potential and the gaps.

17. Build something useful. Pipecat is an open source framework for voice and multimodal conversational AI. Wire it up with Whisper for speech recognition, an LLM for reasoning, and a TTS model for output. You now have a voice agent that works in 50+ languages with no text UI required. This is what AI looks like for most of the world.

18. Get ambitious. Chatterbox is production grade multilingual TTS covering 23 languages with emotion control and voice cloning. It consistently outperforms competing models in blind tests. Build localized AI products for emerging markets where voice is the primary interface.

19. Build infrastructure. Coqui TTS combined with Fairseq’s speech models lets you train custom TTS and ASR for languages with zero commercial support. If you care about Swahili, Bengali, Yoruba, or any of the thousands of languages ignored by big tech, this is where you start.

20. Insane unlock. Combine Microsoft’s VibeVoice for real-time multilingual TTS with on-device small language models like Phi-3 or Gemma. Build fully offline, voice-native AI assistants that work without internet. This is how AI reaches the truly underserved: people without reliable connectivity, without keyboards, without English.

5. How do we make AI compute actually affordable?

The AI industry is spending hundreds of billions on data centers, GPUs, and power. This is unsustainable. Before we get anywhere near AGI, we’ll hit physical limits on energy, rare earth materials, and public tolerance for massive industrial buildouts.

The optimization opportunity is enormous. Most AI workloads are wildly inefficient. The projects below show how much performance you can unlock through better software alone.

21. Start quick. llama.cpp runs large language models on CPUs, Apple Silicon, and consumer GPUs through aggressive quantization. It’s the single best way to understand the inference optimization stack. Run a 70B model on your laptop and see what’s possible when you take efficiency seriously.

22. Build something useful. vLLM is a high throughput LLM serving engine that uses PagedAttention to achieve 10 to 24x higher throughput than naive serving. If you’re deploying any LLM in production, this is table stakes. Deploy it, benchmark it, and understand why serving economics matter more than model quality for most businesses.

23. Get ambitious. DeepSpeed is Microsoft’s distributed training library. ZeRO optimization, CPU offloading, mixed precision training. It makes training runs that would require a full rack of A100s feasible on a fraction of the hardware. This is how you compete with Big Tech on training budgets.

24. Build infrastructure. Unsloth delivers 2 to 5x faster LLM fine-tuning with 80% less memory. A $10,000 training run becomes $2,000. A fine-tuning job that required an A100 now runs on a consumer GPU. This completely rewrites the economics of model customization.

25. Insane unlock. Triton is OpenAI’s GPU programming language. Write custom CUDA level kernels in Python. If you want to build novel compute paradigms (neuromorphic, photonic, custom accelerators), this is the entry point. The next great compute paradigm won’t come from buying more Nvidia chips. It’ll come from someone who understands computation deeply enough to redesign it.

6. What does machine learning look like when it’s continuous and distributed?

Today’s ML is batch-oriented and centralized. Collect data, train model, deploy model, repeat. SPC is asking about something fundamentally different: learning that happens continuously, across distributed nodes, with data that never leaves its source.

This matters enormously for healthcare (hospitals can’t share patient data), finance (banks can’t share transaction data), and any domain where privacy and data sovereignty are non-negotiable.

26. Start quick. Flower is the friendliest federated learning framework. You can run FL experiments on your laptop in 20 minutes. It supports PyTorch, TensorFlow, and JAX. Start here to understand what federated learning actually feels like from the developer side.

27. Build something useful. PFLlib benchmarks 39 personalized federated learning algorithms across 24 datasets. It’s the fastest way to understand which FL approach works for which data distribution. This is invaluable if you’re evaluating whether FL is viable for a specific use case.

28. Get ambitious. FedML is a unified library for distributed training, serving, and federated learning that works across cloud, edge, and on-device. It includes a cross-cloud GPU scheduler. This is production-grade infrastructure, not a research toy.

29. Build infrastructure. FATE, the Federated AI Technology Enabler, is the first industrial grade FL framework. It implements homomorphic encryption and multi-party computation. Build privacy-preserving ML pipelines for healthcare, finance, or cross-organizational collaboration where data legally cannot move.

30. Insane unlock. Petals lets you run 100B+ parameter models collaboratively by combining GPU resources across the internet. Think BitTorrent for LLM inference. Instead of one company owning all the compute, anyone can contribute GPUs and share the capability. This is the decentralized compute future that could make AI accessible without trillion dollar infrastructure investments.

7. How do you defend against AI powered cyberattacks?

Pandora’s box is open. The manpower constraint on sophisticated digital attacks is disappearing. Bad actors now have access to agentic models that can automate reconnaissance, exploitation, and persistence at machine speed.

SPC is asking about both offense and defense. The best defense against AI powered attacks is AI powered defense. These projects let you build both sides.

31. Start quick. DeepTeam lets you red team any LLM in 5 lines of code. 80+ vulnerability types, 10+ attack methods including prompt injection, jailbreaking, and data extraction. Find the holes in your AI system before your users (or attackers) do.

32. Build something useful. Garak is NVIDIA’s adversarial LLM scanner with 100+ attack modules. It maps findings to AI security frameworks and generates compliance-ready reports. Think of it as nmap for LLMs. Essential for anyone shipping AI products.

33. Get ambitious. PyRIT is Microsoft’s Python Risk Identification Tool for generative AI. Enterprise-grade red teaming with multi-turn conversational attacks on RAG pipelines and AI agents. This is what real AI security testing looks like at scale.

34. Build infrastructure. CAI (Cybersecurity AI) is an open source framework for AI driven offensive and defensive security. Build AI agents that monitor networks, detect anomalies, and respond to threats autonomously. It’s been battle-tested in HackTheBox CTFs and bug bounty programs.

35. Insane unlock. Microsoft’s CyberBattleSim creates simulated cybersecurity environments where autonomous agents attack and defend. Combine it with multi-agent reinforcement learning to build AI vs AI security systems where defender agents evolve alongside attacker agents. This is what enterprise security looks like in 5 years.

8. Can we program the physical world like we program software?

Vision-language models, world models, and rapid hardware iteration are collapsing the gap between bits and atoms. SPC is asking about an “API to the physical world” and what great developer experience looks like for physical objects.

This is the robotics moment. The tools have finally gotten good enough that a software developer can build useful physical AI without a PhD in controls.

36. Start quick. MuJoCo is Google DeepMind’s physics simulator. It handles robotic manipulation, locomotion, and contact dynamics. Think of it as the “dev environment” for physical AI. You can simulate a robot arm picking up objects within an hour of installation.

37. Build something useful. LeRobot is Hugging Face’s end-to-end robotics library. Train robot policies from human demonstrations. It supports both real robots and simulation with shared datasets. This is the Hugging Face moment for robotics: suddenly anyone can train and share robot behaviors.

38. Get ambitious. OpenVLA is a vision-language-action model for robotic manipulation. Fine-tune a 7B model on your robot using LoRA and get zero-shot manipulation from natural language instructions. Tell the robot “pick up the red cup” and watch it figure out the motion plan.

39. Build infrastructure. NVIDIA’s Isaac Lab provides photorealistic robot simulation with digital twins, synthetic data generation, and sim-to-real transfer. This is the enterprise stack for physical AI development. Generate millions of training scenarios without ever touching a real robot.

40. Insane unlock. Genesis is a generative physics simulation engine. AI generates entire physics worlds for robot training. Combine this with VLA models and you’ve got robots that learn to manipulate novel objects in AI generated environments, then transfer those skills to the real world. This is how we get robots that can handle anything, not just the objects they were trained on.

9. What new things can we measure and understand about reality with AI?

This is one of SPC’s most philosophical questions. AI isn’t just a tool for analyzing data. It’s a new epistemic instrument that can probe systems through embedded agents, revealing patterns and structures that humans literally cannot perceive.

AlphaFold proved the concept: AI can “see” protein structures that decades of crystallography couldn’t resolve. What else is out there, waiting for the right model to perceive it?

41. Start quick. BayBE is a Bayesian optimization framework for self-driving experiments. It’s used by Merck for real lab automation. Feed it any sensor data and it designs the next experiment to maximize information gain. This is the simplest way to experience AI guided discovery.

42. Build something useful. Label Studio with active learning creates human-AI feedback loops that continuously improve what your sensors detect. Build annotation workflows where the AI learns from your corrections and the data gets better over time.

43. Get ambitious. Boltz is an open source protein structure prediction model approaching AlphaFold 3 parity. Fork it and apply the architecture to your domain’s “folding problem.” Any field where you need to predict 3D structure from sequence data can learn from this approach.

44. Build infrastructure. MinerU is state-of-the-art document parsing that converts PDFs into structured, LLM-ready data. Combined with Meta’s Nougat for scientific paper understanding, you can build translation layers that make AI derived insights legible to researchers who aren’t ML experts.

45. Insane unlock. Chain together the full autonomous discovery pipeline: literature mining (Semantic Scholar API) into hypothesis generation into experimental design (BayBE) into automated execution (Opentrons SDK) into result analysis into publication. This is the self-driving laboratory. Every component exists as open source. Someone just needs to make them work together reliably.

10. Can AI actually bring people closer together instead of isolating them?

AI often feels distancing. But SPC is asking whether it could catalyze authentic relationships by surfacing shared interests, bridging cultural gaps, and handling the logistics that prevent people from connecting.

This resonates. The best communities aren’t ones where AI replaces human interaction. They’re ones where AI handles the busywork so humans can focus on each other.

46. Start quick. Mem0 is a long-term memory layer for AI with user, session, and agent-level memory that persists across conversations. It outperforms OpenAI’s built-in memory by 26% while using 90% fewer tokens. Build AI that actually remembers the context of your relationships.

47. Build something useful. Cal.com is open source scheduling infrastructure. The interesting play: build “you should meet” matchmaking on top of it. Use embeddings to identify shared interests between community members and auto-suggest introductions with proposed times.

48. Get ambitious. Matrix/Synapse is a decentralized, encrypted communication protocol. Build AI augmented community spaces where bots bridge cultural gaps with real-time translation, facilitate introductions based on semantic matching, and surface shared context that humans would never discover on their own.

49. Build infrastructure. AgentSociety is a large-scale simulation of LLM driven generative agents in social environments. Use it to model how AI facilitators change group dynamics, community formation, and relationship patterns before deploying to real communities.

50. Insane unlock. Combine all of the above into an AI Community Operating System: Mem0 for memory, semantic embeddings for matching, Cal.com for scheduling, Matrix for communication, and agent facilitation for logistics. This is the full-stack platform for communities where AI handles everything except the human connection itself. If you’re building communities at scale, this is the endgame.

11. Who’s accountable when AI agents act on their own?

AI introduces non-human actors making decisions at speeds and scales that break existing legal and governance structures. When an AI agent autonomously negotiates a contract, who’s liable? When an agent swarm manipulates a market, who goes to jail?

These aren’t hypothetical questions anymore. Agentic AI is already operating in production environments. The governance infrastructure is scrambling to catch up.

51. Start quick. Search GitHub for “AI Governance Risk Toolkit.” There are open source templates, risk registers, and audit-ready workflows that let you start governance from day one. You don’t need a compliance team. You need a risk register and a logging strategy.

52. Build something useful. VerifyWise is a full AI governance and LLM evaluation platform supporting the EU AI Act, ISO 42001, ISO 27001, and NIST AI RMF. Self-host it and you have a compliance dashboard for every AI product you ship. This is especially relevant if you’re selling to enterprise or regulated industries.

53. Get ambitious. Superagent is a framework for building AI agents with built-in guardrails. Permission systems, action constraints, and audit logging are embedded in the architecture, not bolted on afterward. This is governance by design for agentic systems.

54. Build infrastructure. Combine EthicalML’s Awesome AI Regulation database with Proof of Human Intent (PoHI) systems that create cryptographically verifiable records of human approval for AI driven actions. Build the audit trail that regulators will eventually require.

55. Insane unlock. The 3-Layer Governance Framework maps AI activity across infrastructure, logical, and social layers. Implement this with agent identity systems, cross-organization audit trails, and accountability mechanisms for when AI agents act autonomously across organizational boundaries. This is first-mover territory. Whoever builds the “compliance infrastructure for agentic AI” has a massive market waiting for them.

12. How do we train the workforce for America’s manufacturing comeback?

America is attempting the largest industrial reshoring in generations. SPC is asking about credentialing, career pathways, and training models that make “advanced manufacturing alum” a status identity, not a fallback.

This is a systems design problem. The technology exists. The training infrastructure doesn’t.

56. Start quick. Open Badges is the digital credentialing standard. Issue verifiable, portable skill badges for manufacturing competencies. Start validating skills today instead of waiting for someone to build a four-year degree program.

57. Build something useful. FreeCAD is open source parametric 3D CAD. Combine it with an LLM driven design assistant to lower the barrier to manufacturing design literacy. Build AI tutors that can teach CAD/CAM to someone who’s never opened a design tool.

58. Get ambitious. Meshroom is a photogrammetry pipeline that turns phone photos into 3D models. Build QA systems that verify manufacturing quality from camera images using computer vision. A factory worker takes a photo, AI tells them whether the part meets spec.

59. Build infrastructure. Mainsail with Klipper provides advanced 3D printer firmware and web interface. Build the training simulation platform where manufacturing trainees operate real hardware remotely with AI coaching and automated quality verification. Think “flight simulator for factory workers.”

60. Insane unlock. Combine ROS2 (the robotic operating system) with VLA models for adaptive manufacturing cells, plus Open Badges for verified competencies. Build the full-stack advanced manufacturing academy where graduates have robot-verified portfolios proving they can operate next-gen production lines. Not a certificate on a wall. A video of them programming a robot arm to produce a part to spec, verified by the machine itself. That’s a credential that actually means something.

What should you build first?

If you read through all 12 sections and something resonated, here’s the decision framework:

Pick the topic where you felt the most frustration. Not excitement. Frustration. The “why doesn’t this exist yet” feeling is where startups come from. Excitement fades. Frustration sustains you through the hard parts.

Start at Level 1. Always. Even if you’re experienced. The Level 1 project in each category gives you ground truth about the current state of the art. You can’t identify what’s missing until you’ve used what exists.

If you’re prepping for SPC specifically, know that they’re not looking for people who read their Requests for Curiosity and wrote a memo about it. They’re looking for people who read it and built something. Show up with a GitHub repo, a demo, and an opinion. That’s the application.

If you’re running a hackathon or workshop, mix Level 1 projects across 3 or 4 topics for a breadth sprint. Or go deep on one topic from Level 1 to Level 3 for a focused build weekend. Both work. The worst option is a lecture.

The best preparation for any founder fellowship is the same as the best preparation for starting a company: build something. See what breaks. Talk to people who care about the same problem. Repeat.

Made with Curiosity by 🌐 Worldwide Studios.

Hi Everyone,

We’re hosting our third Claude Tutor session this Friday for people who want to build AI enabled web apps. Also, we’ve had a few people asking for recordings and guides, so we’ll share those too.

Highlights for what’s coming up

1. Build an AI App Line by Line with Claude Tutor (Friday, 10a PT, Virtual)

   We’re building an open sourced tutor, and hosting our third session on Friday. This time we’ll walk through one web app set up line by line.
   

2. AI for Good: Future of Education Open Source Build (Sat 10a PT, SF)

   We’re hosting an open source build day in SF at Studio 45 for those interested in the future impact AI has in new education systems.
   

3. In case you missed it, guides + recordings

• Intro to Claude Tutor, open source agent to help you level up your skills in software engineering through projects

• Intro to Claude Code Playground Plugin, an interactive HTML file for context to Claude Code
  

Coming up

• 5th AI for Science Hack Cell Cultivation @ Monomer Bio (March 14-15)

• We’ll be giving a product talk at NYU’s Flourishing in Age of AI Summit (March 18)

• AI for Science Summit in SF (SF, June 16-17)
  

Keep building,

Michael

Founder 🌐 Worldwide Studios

Ps. We’re running 2hr AI agent build along workshops for teams and communities, like this one for MIT Sloan Alumni. If you want to see one for your role or your team, reply back as we’re designing these with community members for specific use cases.

YC’s latest RFS covers 10 areas where they want to fund their next batch of startups: AI-native product tools, hedge funds run by agent swarms, stablecoin infrastructure, govtech, modern manufacturing, spatial AI, and more. Each idea is exciting on paper. But the gap between “this sounds cool” and “I have a working prototype” is where most people stall in application stage.

This guide closes that gap. For each of the 10 RFS topics, we found 5 open-source GitHub projects you can actually clone, run, and build on — ranging from Level 1 (get something working this afternoon) to Level 5 (serious infrastructure that could become the backbone of a funded startup).

The best YC applications don’t describe an idea. They demo one.

What are YC’s Spring 2026 Requests for Startups?

YC publishes a “Requests for Startups” list each batch — essentially a public signal of what problems they’re most excited to fund. For Spring 2026, the list spans ten categories:

1. Cursor for Product Managers — AI that helps teams figure out what to build

2. AI-Native Hedge Funds — agent swarms that trade like quant teams

3. AI-Native Agencies — service businesses with software margins

4. Stablecoin Financial Services — DeFi benefits, TradFi compliance

5. AI for Government — processing forms, permits, and paperwork at scale

6. Modern Metal Mills — software-defined American manufacturing

7. AI Guidance for Physical Work — real-time coaching through wearables

8. Large Spatial Models — AI that reasons about 3D geometry natively

9. Infra for Government Fraud Hunters — accelerating whistleblower investigations

10. Make LLMs Easy to Train — tooling that makes model training less painful

What’s notable: several of these came directly from YC founders sharing what they’re seeing on the frontier. These aren’t theoretical — they’re market gaps that people building real companies have already identified.

How do I start building for “Cursor for Product Managers”?

The core insight here is that coding agents (Cursor, Claude Code) are great at building once you know what to build. But the upstream work like talking to users, synthesizing feedback, deciding what problems are worth solving is still entirely manual.

The opportunity is an AI system that takes customer interviews and usage data as input and outputs prioritized feature specs ready for a coding agent. Think of it as closing the loop between product discovery and product delivery.

Where to start on GitHub

If you have one weekend: Clone Cursor-for-Product-Managers. It’s a literal implementation of this YC idea using Cursor IDE with structured PM frameworks (Continuous Discovery Habits, evidence-guided development). It gives you AI-assisted PRD generation, task breakdown, and progress tracking inside your editor.

If you want a feedback pipeline: LogChimp is an open-source alternative to Canny and ProductBoard. Self-host it, pipe customer feedback in, and you’ve got the raw data layer that an AI product discovery tool needs to work from.

5 more projects on GitHub

⚡ 1 Cursor-for-Product-Managers AI-assisted PM workflows in Cursor. PRDs, task breakdowns, discovery frameworks.

⚡ 2 LogChimp Open-source feedback tracking. Aggregate user input for AI analysis.

🔧 3 Plane Full project management platform. Add AI layers for spec generation

🔧 4 OpenAI Whisper Transcribe customer interviews locally. The input layer for AI product discovery

🔥 5 CrewAI Multi-agent orchestration. Build a PM agent swarm (feedback analysis → PRD → dev tasks)

The Level 5 unlock here is real: CrewAI lets you wire up a team of specialized agents where one analyzes customer feedback, another writes product specs, and a third breaks specs into coding tasks. That’s the full “Cursor for PMs” loop running autonomously.

What open-source tools exist for building an AI hedge fund?

This is one of the most active areas on GitHub right now. The thesis is straightforward: quantitative trading was once considered fringe, and now it’s obvious. AI-native trading — where agent swarms parse 10-Ks, synthesize analyst ideas, and execute strategies — is at a similar inflection point.

The biggest quant funds are slow to adopt LLMs (one YC partner couldn’t even get compliance to approve ChatGPT). That lag is the opportunity.

Where to start on GitHub

Best first project: virattt/ai-hedge-fund has 2K+ stars and lets you run a multi-agent trading simulation in minutes. It includes agents modeled after Warren Buffett, Cathie Wood, Bill Ackman, and Michael Burry — each with distinct investment philosophies that collaborate on trade decisions. Clone it, add API keys, backtest.

For serious quant research: Microsoft’s Qlib is a production-grade platform that supports supervised learning, market dynamics modeling, and reinforcement learning. It’s integrated with their RD-Agent for automated research. This is what “AI-native from the ground up” actually looks like at scale.

5 more projects

⚡ 1 ai-hedge-fund Multi-agent trading simulator. Buffett, Wood, Burry agents analyze stocks together

⚡ 2 awesome-ai-in-finance Curated index of every LLM/deep learning finance tool and strategy

🔧 3 FinRLDeep RL library for automated trading. Train agents on historical market data

🔧 4 AutoHedge Full API-driven hedge fund, trading director, quant analyst, risk manager, execution agent.

🔥 5 Qlib (Microsoft) Production quantitative investment platform with automated R&D pipeline.

Worth noting: none of these make real trades. They’re simulations and research platforms. But the gap between “backtested simulation” and “live trading” is a product decision, not a technical one.

Can you really build an AI agency with software margins?

The traditional agency model is brutal: low margins, linear scaling (more clients = more people), and constant re-selling. AI changes the math.

Instead of selling software to clients to help them do the work, you use the software yourself and sell the finished product. A design firm that produces custom work for clients before the contract is signed. A law firm that writes legal docs in minutes. An ad agency that creates video ads without physical shoots.

The projects below aren’t “AI agency” tools specifically — they’re the infrastructure that makes an AI agency possible.

Where to start on GitHub

⚡ 1 AgentGPTBrowser-based autonomous agent. Give it a goal, watch it execute. Client demo in minutes

⚡ 2 n8nSelf-hosted workflow automation (400+ integrations). Build agency delivery pipelines

🔧 3 Composio 250+ tool integrations for AI agents, email, CRM, reports, file generation

🔧 4 OpenHands (formerly OpenDevin) Autonomous AI software engineer. Give it specs, get working code back (40K+ stars)

🔥 5 DifyVisual LLM app builder. Create and white-label AI applications for clients.

The Level 5 play with Dify is particularly interesting for agencies: you build AI-powered tools with a visual workflow builder, white-label them, and sell them as custom solutions. Non-technical team members can create client deliverables. That’s the “software margins” part working in practice.

What should I build for stablecoin financial services?

The regulatory landscape is shifting fast. The GENIUS and CLARITY Acts are creating a middle ground where stablecoins can operate with DeFi benefits (better yield, tokenized assets, instant settlement) under traditional compliance frameworks.

The financial services layer on top of this infrastructure is still mostly unbuilt. That’s the gap.

Where to start on GitHub

For learning the mechanics: Cyfrin’s foundry-defi-stablecoin walks you through building a decentralized stablecoin from scratch — deposit WETH/WBTC, mint USD-pegged tokens. It’s from Patrick Collins’ course and is the clearest tutorial for understanding how stablecoins actually work under the hood.

For understanding real compliance: Circle’s USDC smart contracts are the actual implementation of the most widely-used regulated stablecoin. If you’re building anything in the “regulatory middle ground,” this is the reference architecture.

5 more projects

⚡ 1 foundry-defi-stablecoin Build a stablecoin from scratch. This is the best tutorial for understanding the mechanics

⚡ 2 awesome-decentralized-finance Master index of DeFi protocols, stablecoins, L2s, RWA tokenization

🔧 3 Superfluid Protocol Real-time money streaming on Ethereum, programmable cashflows by the second

🔧 4 Aave V3Battle-tested DeFi lending ($14B+ TVL). Fork it for stablecoin yield products

🔥 5 Circle USDC Contracts The actual USDC implementation — reference architecture for compliant stablecoins.

How do I build AI tools for government?

Government is the biggest customer on earth with trillions in annual spending, and it’s processing most of that with paper, PDFs, and manual workflows. The first wave of AI helped citizens fill out forms faster. The second wave needs to help the government process those forms.

Selling to government is hard. But the contracts are sticky and massive once you land them.

Where to start on GitHub

Fastest path to something real: Paperless-ngx is a document management system with OCR, auto-tagging, and full-text search that turns paper into searchable digital archives. It directly addresses the “printing and processing by hand” problem. Layer AI classification and routing on top and you’ve got a govtech product.

For citizen engagement: Decidim is already deployed in 400+ cities worldwide as a participatory democracy platform. It’s proven in government procurement — which is half the battle.

5 more projects

⚡ 1 awesome-govtech Full index of govtech platforms, tools, frameworks, and datasets

⚡ 2 Decidim Participatory democracy platform deployed in 400+ cities worldwide

🔧 3 CKAN Powers data.gov. the standard for government data portals

🔧 4 DocumensoOpen-source DocuSign digital document signing and processing

🔥 5 Paperless-ngx OCR + auto-tagging + full-text search for paper documents — add AI routing for a full govtech stack

What does “modern metal mills” mean and what can I build?

When people talk about reindustrializing America, they focus on labor or geopolitics. But the real problem is that American metal mills are running on systems designed decades ago. Lead times of 8-30 weeks. Production planning optimized for tonnage, not speed. Tribal knowledge held by a few operators who are about to retire.

Software and automation technology are finally good enough to rethink the whole system. AI-driven planning, real-time MES, and modern automation can compress lead times and raise margins simultaneously.

Where to start on GitHub

To digitize a shop floor fast: ERPNext gives you a complete manufacturing ERP — BOMs, work orders, production scheduling — in a day. It’s not a toy: it’s used by real manufacturing companies worldwide.

For the scheduling brain: frePPLe is the most recognized open-source Advanced Planning and Scheduling tool. It implements theory of constraints, pull-based planning, and lean manufacturing principles. This is the “AI-driven planning” piece of the modern mill.

5 more projects

⚡ 1 ERPNext Complete manufacturing ERP BOMs, work orders, scheduling in a day

⚡ 2 frePPLe Open-source production planning constraint-based scheduling, bottleneck optimization

🔧 3 Libre MES Real-time manufacturing execution Grafana + InfluxDB for OEE dashboards

🔧 4 IMES Intelligent MES with mathematical optimization LP for resource usage, scheduling algorithms

🔥 5 OpenI40 Platform Enterprise-grade Advanced Production Scheduler for Industry 4.0

The full stack looks like: ERPNext for orders and BOMs → frePPLe for optimized scheduling → Libre for real-time execution monitoring → IMES or OpenI40 for intelligent dispatching. Combine with energy monitoring and you’ve got the “software-defined mill” YC is describing.

How do I build AI guidance for physical workers?

You know the scene in The Matrix where Neo plugs in and says “I know Kung Fu”? That’s the metaphor YC is using — and the technology is closer than you think.

Multimodal AI can now see and reason about real-world situations. The hardware (phones, AirPods, smart glasses) is already everywhere. And skilled labor shortages make this economically urgent. An AI that watches through a camera and talks a worker through a repair — “turn off that valve,” “use the ⅜ inch wrench,” “that part looks worn, replace it” — makes a new hire effective on day one.

Where to start on GitHub

$20 prototype: OpenGlass turns any pair of glasses into AI-powered smart glasses with an ESP32 chip. Camera, mic, AI processing. Build it in an afternoon, and you’ve got a working demo of “AI sees what you see.”

Production-ready platform: OpenSource AI Glasses is specifically built for the use cases YC describes — industrial maintenance, medical, field service. AR annotations on shared video, remote expert consultation, step-by-step SOP guidance overlaid on real equipment.

5 more projects

⚡ 1 OpenGlass ESP32-powered AI glasses $20 in parts, afternoon build, camera + mic + AI

⚡ 2 MentraOS Cross-platform smart glasses SDK write once, deploy on any glasses hardware

🔧 3 VisionClaw Real-time AI assistant for Meta Ray-Bans — voice + vision + 56 agentic tools

🔧 4 OpenSource AI Glasses Full platform: AR annotations, remote expert guidance, SOP step-by-step overlays

🔥 5 Brilliant Labs Frame Fully open-source smart glasses hardware + firmware display, camera, AI processor.

What are large spatial models and why do they matter?

LLMs handle language. But they can’t robustly reason about 3D space — object relationships, mental rotation, physical manipulation. This limits AI’s ability to understand and interact with the physical world.

The opportunity is building foundation models that treat geometry and physical structure as first-class primitives, not approximations layered on top of language. YC says a company that succeeds here “could define the next AI foundation model, on the scale of OpenAI or Anthropic.”

That’s a big claim. Here’s where the research and tooling stands.

Where to start on GitHub

⚡ 1 Awesome-Spatial-Intelligence-in-VLM Master paper list every benchmark, method, and dataset in spatial reasoning

⚡ 2 SPARE3D CVPR benchmark for 3D spatial reasoning cognitive science-based evaluation tasks

🔧 3 Awesome-Robotics-3D 200+ papers with code scene understanding, manipulation, navigation with VLMs

🔧 4 RoboSpatial (NVIDIA) NVIDIA’s spatial annotation pipeline used by Qwen3-VL and Gemini Robotics

🔥 5 Awesome-World-Models Comprehensive world model research 3D generation, embodied AI, physics simulation

The Level 4 project is particularly telling: NVIDIA’s RoboSpatial is already being used by Qwen and Google’s Gemini to train spatial understanding. The data generation pipeline — not just the models — is where the moat is being built.

How do I build tools for government fraud investigation?

The U.S. government hemorrhages tens of billions annually in fraud. Medicare alone loses massive amounts to improper payments. The False Claims Act’s qui tam provision lets private citizens file lawsuits on behalf of the government and keep a percentage of whatever’s recovered.

Right now, that process is painfully slow: an insider tip leads to months or years of manual document review. The opportunity is AI systems that can take a tip and automatically organize evidence — parsing PDFs, tracing corporate structures, packaging complaint-ready files.

Where to start on GitHub

⚡ 1 awesome-fraud-detection-papers Academic foundation graph networks, deep learning, and ML for fraud detection

⚡ 2 PyOD 50+ anomaly detection algorithms flag outliers in billing, procurement, or claims data

🔧 3 AI4Risk/antifraud Financial fraud detection framework adapt for Medicare billing or procurement fraud

🔧 4MISP Threat intelligence sharing platform used by governments adapt for fraud pattern sharing

🔥 5 Tirreno Open-source security analytics log analysis, pattern detection, audit trails at scale

YC specifically calls out that founder profile matters here. They want teams where at least one founder has FCA counsel, compliance, or audit experience. The best approach: pair a domain expert with a technical founder who can adapt these tools.

What’s the best way to make LLM training easier?

Training LLMs is still “surprisingly difficult,” according to YC partner Gabriel Birnbaum, who’s spent three years training models at Can of Soup. Broken SDKs, busted GPU instances you discover after 30 minutes of spin-up, major bugs in open-source tooling.

The products that need to exist: APIs that abstract training, databases for managing terabytes of data, and dev environments built for ML research. As model specialization becomes more important, these tools become the foundation of how all software gets built.

Where to start on GitHub

No-code option: H2O LLM Studio gives you a GUI for fine-tuning LLMs. Upload data, pick a model, tune hyperparameters visually, export. Zero coding. This is what “make it easy” looks like for non-ML-engineers.

For serious training infrastructure: OpenRLHF is the first RLHF framework built on Ray + vLLM. It handles 70B+ parameter models with distributed scheduling. CMU uses it for teaching. It reproduced DeepSeek-R1 training. This is production-grade.

5 more projects

⚡ 1 LLM-Finetuning-Toolkit One YAML config → ablation experiments across models, prompts, and techniques

⚡ 2 H2O LLM Studio No-code GUI for fine-tuning point-and-click model training and evaluation

🔧 3 Axolotl Most popular fine-tuning framework YAML configs, LoRA/QLoRA/FSDP/DeepSpeed (8K+ stars)

🔧 4 OpenRLHF Scalable RL training on Ray + vLLM PPO, GRPO, REINFORCE++ for 70B+ models

🔥 5 HuggingFace TRL The emerging standard SFT, DPO, PPO with HF ecosystem.

Combined with HF Skills, Claude Code can submit and monitor GPU training jobs

Frequently Asked Questions

How do I decide which YC RFS topic to pursue?

Pick the one where you have an unfair advantage. Domain expertise matters more than technical background. YC explicitly calls this out for fraud investigation (they want former FCA counsel) and govtech (you need to know how to sell to government). For AI-native agencies, relevant experience running an agency gives you a massive head start. For modern metal mills, understanding manufacturing operations is the moat.

Can I use these open-source projects in my startup?

Check each project’s license. Most listed here are MIT, Apache 2.0, or similar permissive licenses that allow commercial use. A few (like frePPLe and some DeFi protocols) use AGPL or custom licenses that have specific requirements. Always verify before building a business on top of them.

How many of these do I need to build before applying to YC?

One working demo beats ten pitch decks. Pick the project closest to your idea, get it running, then extend it with your own innovation. YC wants to see that you can build and that you understand the problem space not that you’ve assembled a Frankenstein of open-source repos.

When is the YC Spring 2026 application deadline?

Check ycombinator.com/apply for the latest deadline. Batches typically have rolling admissions with a soft deadline, but earlier applications get more review time.

What’s the difference between Level 1 and Level 5 projects?

Level 1-2 projects get you a working prototype in hours. They’re the “start quick” options for validating an idea or building a demo. Level 3-4 projects are production-grade infrastructure you’d actually build a company on. Level 5 projects are frontier tools — combining them with your own innovation is where breakout startups emerge.

50 projects. 10 YC focus areas. Every difficulty level from “afternoon hack” to “venture-scale infrastructure.”

It’s never been a better time to be a small team that wants to build big things.

Made with Curiosity by 🌐 Worldwide Studios.