Claude Code and Codex Projects of 2026: What to Borrow

The best project to learn from solves a problem you recognize and makes its decisions inspectable. These Claude Code and Codex projects offer useful patterns for small businesses, nonprofits and solo builders. This week, choose one pattern, check the license before taking code, and write the cases your own version must pass.

Our selection favors understandable workflows, human control and evidence over spectacle. It is an editorial shortlist, not a benchmark of everything built this year. Anthropic describes the Claude Code projects in its hackathon and workplace stories. OpenAI identifies its Build Week projects with Codex. The builder and the model inside a finished app are different things: software built using Codex can itself call an AI model, or run ordinary code without one.

A repository, often shortened to repo, is a project's collection of source files and history. A license states the rights and conditions for using that code. An SPDX identifier is a standard short license name, such as MIT. A public demo lets you see a product; it does not establish permission to copy its implementation. GitHub explains why public visibility alone supplies no general reuse license.

Six Claude Code projects worth studying

CrossBeam: turn a document into accountable tasks

Builder: Mike Brown. Built with Claude Code. CrossBeam takes building plans and correction letters and turns the issues into separate work for agents, producing an action plan. Anthropic credits Brown and describes tests as part of his build. Project profile.

Borrow the idea: a contractor's checklist should connect every requested change to the document that requires it. Keep the original requirement beside the proposed response so someone can spot a misunderstanding. A nonprofit could apply the same structure to a grant's required attachments. Neither adaptation should claim that a completed checklist guarantees approval.

Reuse: MIT, for the CrossBeam repository snapshot. Retain its copyright and permission notice. Its README distinguishes the snapshot from the current commercial product and says demonstration plans were supplied with permission. Do not treat those documents as freely reusable assets.

Wrench Board: let a measurement change the answer

Builder: Alexis Chapellier. Built with Claude Code. Wrench Board combines electronics schematics, board layouts and symptoms, then guides a technician toward measurements and updates its hypotheses. Chapellier separated responsibilities, wrote specifications and benchmarked during debugging. Project profile.

Borrow the idea: ask for the next useful observation instead of generating a long list of confident guesses. A service intake form can ask whether the fault affects one item or every item, then show the reason for the next question. The person still decides what work is appropriate.

Reuse: custom proprietary terms, API NOASSERTION. The Wrench Board license permits specified internal repair-business use with notices retained. Redistribution, hosted services and competing-product use require permission. Ask before adapting it into your own product. We did not test repair accuracy.

Conductr: keep the dependable engine underneath

Builder: Asep Bagja Priandana. Built with Claude Code. Conductr is a browser music instrument that combines a fixed note-generating engine with AI arrangement decisions. Anthropic describes that separation explicitly. Project profile.

Borrow the idea: keep the part that must behave consistently in ordinary code. For an event planner, capacity arithmetic can stay fixed while a model explains seating alternatives. A model failure should leave the capacity check usable. This is an architectural lesson; it does not require copying a music application into a business site.

Reuse: Apache-2.0, from the Conductr repository. Keep the license and applicable notices, mark changed files and preserve required NOTICE attribution. Its patent grant has conditions; it grants no general trademark rights.

Tekton: make the evidence visible inside the experience

Builders: Holly Tang and Austin Burgess. Built with Claude Code. Tekton reconstructs historical architecture and exposes the evidence behind components. The builders used separate verifier agents to check citations and placement. Project profile.

Borrow the idea: attach the source to the thing a visitor is examining. A community history project could label a feature as documented, inferred or disputed, with the relevant record available beside it. Independent checks should examine the evidence, rather than simply praise the generated result.

Reuse: no license found in the Tekton repository. Ideas only, ask the authors. The article's intention to release work openly is not a license grant.

Respiro: start with a problem the builder understands

Builder: Kostiantyn Vlasenko, a nontechnical project manager. Built with Claude Code. Anthropic profiles Respiro as a stress-management app and describes specialist development and review roles. Project profile.

Borrow the idea: make a small intervention fit an existing moment in someone's day. For a volunteer coordinator, that might mean a preparation checklist immediately before a shift, rather than a dashboard volunteers must remember to visit. Interview the people who will use it before choosing the screen.

Reuse: the reviewed profile links an app listing, without a source repository. No code license verified: ideas only, ask the author. We did not assess medical effectiveness or repeat the profile's differing build-duration descriptions.

CLAFTS: prepare work where the person already reviews it

Builders: Jared Sires, with co-builder John Albert. Built with Claude Code. Anthropic describes CLAFTS preparing email replies in Gmail using relevant context and current documentation, with drafts waiting for review. Sires began without coding experience. GTM engineering story.

Borrow the idea: put a proposed answer beside the evidence and leave it in a familiar review step. A small organization could prepare an internal response outline from approved public policies. Keep sending under the person's control in your own design, and review data access before connecting any mailbox.

Reuse: an internal workflow described in an article is not a public code release. No public repository or code license was established here: ideas only, ask the authors.

Eight Codex projects with transferable lessons

These are the winners described in OpenAI's Build Week article. The descriptions below follow that account and the linked project records; they are not results from running the software ourselves.

veTriage: separate the need from the available slot

Builder: Erin Downes VMD. Built with Codex. veTriage helps receptionists collect information and route cases for clinical review. OpenAI describes a veterinarian with no coding background translating domain expertise into a workflow while keeping medical decisions with clinicians. Project record.

Borrow the idea: maintain separate fields for a request's importance and your organization's capacity. A packed appointment book must not silently turn an urgent request into a routine one. Our worked example below applies this separation to equipment service intake, without copying clinical rules.

Reuse: the reviewed project record provides a hosted prototype, without a repository. No code license verified: ideas only, ask the author.

Pulse: ask when the evidence is unclear

Builder: Mohamed Mostafa Mohamed Labib Abu Taleb. Built with Codex. Pulse is a research prototype for cardiac-arrest workflow support. OpenAI describes a model interpreting speech while auditable code tracks state and requests confirmation when needed. Project record.

Borrow the idea: represent uncertainty explicitly. In an ordinary service checklist, an unclear answer should produce a clarification step instead of a guessed completion mark.

Reuse: Pulse's license file contains MIT text plus an additional notice prohibiting use to guide real patient care. GitHub's API reports NOASSERTION because the file does not match a recognized SPDX license. We recommend studying the workflow idea; resolve the combined terms before adapting code. This is not a clinical tool recommendation.

Echo Canvas: let people inspect a change before accepting it

Builder: Kevin Yang. Built with Codex. Echo Canvas lets people sketch and hear acoustic spaces. OpenAI describes constrained model output alongside deterministic geometry and acoustic calculations. Project record.

Borrow the idea: a preview should reflect the actual calculation. For an event setup planner, a changed layout should update the real seat count before anyone approves it. Deterministic means the same inputs and rules produce the same result, like multiplying rows by seats per row.

Reuse: the reviewed record links a demo, without a repository. No code license verified: ideas only, ask the author.

MCP-Sentinel: constrain the reviewer as well as the builder

Builder: Malik Bashaar Javaid. Built with Codex. OpenAI calls the project Sentinel; its repository is MCP-Sentinel. It combines source checks, constrained model review and isolated behavioral probes. The model cannot invent executable probes or cite nonexistent code. Official profile.

MCP means Model Context Protocol, a shared way for assistants to call named functions. An MCP server provides those functions, called tools. A connector is the connection through which an assistant uses them. A function that checks published opening hours is an everyday example.

Borrow the idea: require every finding to identify real evidence, and keep checks available when the model is unavailable. Reuse: MIT, confirmed through the GitHub license API on November 7, 2026 at 18:42:33 UTC. Preserve the copyright and permission notice with copied code. The current README calls it PortunusMCP Sentinel and excludes JavaScript; TypeScript support is static-only, meaning checks read source without executing it. We did not run it. For checks on your own supported server, follow the connector guide's security section.

Mechanica: answer from evidence or decline

Builders: Weiying Zhu, Yukun Li and Shan Wei. Built with Codex. Mechanica presents interactive historical machines, labeled evidence and competing reconstructions. Its AI guide is designed to cite evidence or decline. Project record.

Borrow the idea: a public-service answer should expose its basis and admit when the necessary source is missing. A nonprofit program finder could show the eligibility document and its checked date, while leaving the official determination to the program.

Reuse: MIT, from the Mechanica license API. Keep notices if adapting code. Independently check rights to historical images, models, translations and other content before taking those assets.

Dấu: measure first, explain second

Builder: Robert Huynh. Built with Codex. Dấu visualizes Vietnamese tones. OpenAI describes signal processing evaluating pronunciation, model-generated coaching, and another attempt when evidence is unclear. Project record.

Borrow the idea: separate a measured result from its explanation. A training tool can display the actual checklist result before explaining the next practice task. An unclear recording or missing answer needs a retry state visible to the learner.

Reuse: the reviewed record links a hosted app, without a repository. No code license verified: ideas only, ask the author.

Second Voice: confirmation is part of accessibility

Builder: Ravitez Dondeti. Built with Codex. Second Voice proposes sentences from partial speech and context; the person selects or edits before speech output. Project record.

Borrow the idea: make confirmation usable for the actual person. A small set of clear choices, a visible edit option and a reliable cancel route matter more than a decorative assistant avatar. Test the effort required to correct a wrong suggestion.

Reuse: the repository linked by the project was unavailable in both the API check and a browser check on November 7. No license found in the accessible evidence: ideas only, ask the author. We have not guessed a replacement address.

AirBridge: verify that the action really happened

Builder: Adam Tarantino. Built with Codex. AirBridge streams Windows audio to AirPlay devices. Its voice assistant works through a local policy layer that permits actions and checks hardware results. Official profile.

Borrow the idea: distinguish requested, permitted and completed. A shop's internal checklist should never display success merely because an assistant proposed an action. Show the state actually returned by the system responsible for it.

Reuse: MIT, confirmed in the AirBridge license API. Preserve the notice when adapting its code, and inspect dependencies separately.

The license check, project by project

All times below are UTC on November 7, 2026. Repository rows record the GitHub API and license-file read; other rows record the article or project-record review. NOASSERTION means the API did not identify a standard license. It does not mean public domain. Where no code license is verified, our recommendation is ideas only.

The table is a dated snapshot; later files may carry different terms. Check the exact version and any file-specific terms before adoption. A dependency is another package the project relies on; it can impose conditions beyond the top-level license.

What recurs, and where the comparison stops

The strongest common pattern is a narrow model role around an inspectable process. Pulse tracks state in code; Echo Canvas calculates geometry; Dấu measures the signal; Sentinel limits review and probes; veTriage leaves clinical decisions to clinicians. Conductr's fixed engine is a clear Claude-side parallel. Wrench Board, by contrast, uses model reasoning to update diagnostic hypotheses. These designs differ, and they do not show that every winner delegates decisions to deterministic code. OpenAI winners, Conductr profile, Wrench Board profile.

Domain knowledge matters because it supplies the cases and exceptions. Respiro, veTriage and CLAFTS start from work their builders understand. Anthropic's marketing story describes Austin Lau building design and advertising workflows with review before upload. Its field-marketing story describes Adam Ward turning feedback into explicit rules, including retaining exact source URLs instead of inventing links. For our own adaptation, we would enforce that URL rule in code as well as instructions.

Verification means comparing output with something outside the output itself. Tekton checks references. Anthropic's Opus 4.7 account describes Benjamin Torralbo's MaestrIA being evaluated against cases assessed by an experienced tradesperson. A neat answer is insufficient evidence that it is right.

The practice articles explain ways to organize that work. A verification skill packages repeatable checks and instructions; a subagent handles a delegated task in a separate context. A hook runs a defined action at a workflow event. For a small project, start with a written specification and repeatable checks. Add delegation or recurring runs only when you can explain what they do and how failure becomes visible.

Borrowing safely: a practical license card

Study the problem and write your own implementation specification. The U.S. Copyright Office distinguishes ideas from protected expression. Code, expressive content, branding, patents and contractual access terms are separate questions. A code license does not automatically clear someone's data, photographs, screenshots, name or logo. Check those rights separately and ask for permission where needed. GitHub's licensing guidance.

Copyleft is a license condition that preserves specified freedoms when covered work is shared. It does not mean commercial use is forbidden. The scope differs: GPL covers qualifying combined derivative work, while MPL generally works at the covered-file level. Ask a qualified reviewer when combining licenses or interpreting unusual additional terms.

Keep a reuse log with the version, license, read date, copied component, changes and notice location. Credit the origin in your README, the project's introductory document, and on the website where appropriate. Credit is good practice; it does not replace license conditions. Check dependencies and assets before release, keep secrets and customer data out of AI refactoring inputs, and rerun your tests after adapting anything. Refactoring means changing code's structure while intending to preserve its behavior. It does not erase the source's license.

Find a project → Read what it does
                    ▼
             Check the license
             ├ No license: ideas only;
             │ ask the author
             └ Open license: note obligations;
               check other assets
                    ▼
             Write your own spec
                    ▼
          Build with Claude Code or Codex
                    ▼
            Test against your cases
                    ▼
          Credit and keep a reuse log

Turn one idea into your own project this month

Here is an original equipment-service intake example inspired by veTriage's separation of need and capacity. It copies no clinical rules or third-party code. The proposed schedule below is a planning aid and promises no delivery date.

Step 1, owner, first week: define the decision. Write down the information staff need before choosing the next contact route: service category, model family, symptom category and whether a required fact is unknown. Keep names and contact details out of this prototype. The owner supplies the real escalation policy; the model must not invent repair instructions. Done when: staff agree on ordinary, incomplete and escalated examples and the expected next step for each.

Step 2, owner and developer: separate facts from language. Ordinary code checks required fields and applies the approved routing rules. Capacity is displayed separately. The model may summarize the customer's description and propose a clarification, but cannot downgrade a route, invent availability or claim an appointment exists. Unknown inputs stay unknown. Done when: each field has a source, permitted use and failure behavior.

Step 3, developer, second week: give the builder a bounded brief. Use Claude Code or Codex to implement your own specification with synthetic examples, meaning made-up records containing no real customer information. Ask it to identify ambiguities before coding and show the checks with each change. Keep the ordinary form usable if the model fails. Done when: a reviewer can follow every result back to a rule or supplied fact.

This is an original planning prompt; it installs and contacts nothing:

Build a draft equipment-service intake from our approved rules.
Keep request routing and appointment capacity separate.
The model may summarize and ask for clarification only.
Missing facts must remain unknown.
Do not send messages, reserve slots or add external services.
Use synthetic records. Show the rule behind each route.
List ambiguities and provide tests before requesting release.

Step 4, owner and developer, third week: challenge the result. Test an empty description, conflicting answers, an unavailable slot, repeated submission and an instruction embedded inside customer text. That text is data and carries no authority to change the workflow. Turn the model off and confirm that the approved routing rules still work. Check keyboard use and whether staff understand the reason shown. Done when: expected and actual results agree, and disagreements have an owner and a fix.

Step 5, owner, final week: pilot the review step. Let staff compare the draft with their existing process before relying on it. Measure corrections and unresolved cases. Keep a route back to the old process. If a customer-facing form is later added, the person reviews and sends; an assistant preparing fields is not permission to submit. Done when: the owner accepts the scope, data handling, maintenance responsibility and release checks.

If the useful next step is an assistant connection, use our connector blueprints for public information, nonprofit programs, events and WordPress. Use the directory guide after the underlying function works. A directory is a discovery catalog; appearing there does not prove a workflow succeeds.

Ideas we would test on our own small sites

We would test Mechanica's evidence-or-decline approach for source-backed answers, Conductr's separation of a reliable engine from model suggestions, and Second Voice's deliberate confirmation step. Those are candidate design ideas, and we have announced no builds.

In our case, the public connector documentation already distinguishes returned information and links from completed actions. The privacy explanation describes what arguments reach the server and the limits of logging assurances. Any future adaptation would need to agree with those actual behaviors, rather than copy another project's privacy promises.

Where the revenue could come from

Documented paid offerings: Respiro's App Store listing offers monthly and annual Pro subscriptions through in-app purchases. CrossBeam's procurement page describes paid agency engagements scoped around permit volume, review functions and setup. We read these on November 7, 2026 at 18:55:02 and 18:55:18 UTC respectively. They establish ways customers can pay. They do not verify revenue, sales counts or profit. CrossBeam's current paid product is distinct from its MIT hackathon snapshot.

Plausible models to test: a web professional could sell the setup of an original intake workflow, then charge for maintaining approved rules and integrations. An independently written template could include examples and support. A subscription needs continuing value, such as maintained source information or team reporting. For a nonprofit, recovered staff time could support more service delivery; it is not automatically donation income.

MIT and Apache-licensed code can support paid implementation, support or hosting when obligations are met. Sponsorship is one more possible route among several. Wrench Board's narrower license permits specified paid repair activity internally; it does not authorize reselling the software. These are proposed earning models based on the license card; we make no claim that the featured builders earn that way.

What is not established: veTriage's pilot does not prove a paying customer. CLAFTS' reported time savings do not prove incremental sales. We established no paid offering or revenue for the remaining shortlisted projects. That is a limit of this review; it does not mean their builders earn nothing.

For your own pilot, record the payer, what they buy, the licensed component and the maintenance cost. Count attributable payments separately from staff hours recovered. Value those hours using your actual labor cost after subtracting review and correction time. Neither a hackathon prize nor a promising demo establishes recurring income.

Download the worksheets

• Borrow from open projects license kit (.md): the license card, dated project table, reuse log, adoption checklist, specification worksheet and attribution templates.

For the broader owner-led process of defining a useful first product, my book The $97 Launch is related reading. Start this exercise by filling the kit's problem, decision and test-case fields.

Related reading

• MCP directories and listing steps
• Build connectors for nonprofits, events and WordPress
• What getting an MCP connector listed takes
• MCP servers for small business
• Connector permissions for small businesses
• Site launch design, search and AI readiness
• AI projects on Devpost that made real money, and the ones that only won prizes
• How DoorDash, Amazon and Starbucks use AI agents, and what a small shop can copy

Fact-check notes and sources

Reads are dated November 7, 2026, UTC. This is source research. We did not audit the software: no featured project was installed or run, no third-party MCP server was called, and dependency or asset rights were not exhaustively checked. Project behavior is attributed to publishers and builders. Our proposed adaptations and monthly schedule are recommendations. No prices are quoted.

• OpenAI winners: 18:42:41. The linked Devpost records were reviewed in a browser between 18:25 and 18:41; those records supplied repository and demo links. Second Voice's unavailable repository was confirmed in a browser at 18:44:16.
• Anthropic's Opus 4.6, Opus 4.7 and Opus 4.8 profiles: 18:43:05, 18:43:06 and 18:43:07. Respiro: 18:43:09.
• Workplace examples: GTM, 18:43:19; marketing, 18:43:20; field marketing, 18:43:22.
• Further full reads informed selection and limits: cybersecurity, 18:43:23; Datadog, 18:43:25; CodeRabbit, 18:43:27; Outtake, 18:43:29; developer onboarding, 18:43:30; code migration, 18:43:32.
• Practice reads: loops, 18:43:33; verification skills, 18:43:35; steering and hooks, 18:43:36; subagents, 18:43:38; auto mode, 18:43:40; artifacts, 18:43:41; routines, 18:43:43.
• U.S. Copyright Office, what copyright protects: 18:51:12.
• Paid-offering checks: Respiro App Store, 18:55:02; CrossBeam procurement, 18:55:18. No price amounts or realized revenue are asserted.
• License API reads appear in the project table. CrossBeam's README was read at 18:45:31; Sentinel's at 18:42:34. Tekton's complete repository tree corroborated the missing license at 18:46:07. The linked license-card texts were read at MIT 18:42:36, Apache 18:42:37, BSD-2 18:42:38, BSD-3 18:42:39, GPL 18:42:41, AGPL 18:42:42 and MPL 18:42:43. GitHub's no-license guidance was read at 18:42:44.

This post is informational, not legal advice. Mentions of third parties are nominative fair use. No affiliation or endorsement is implied.