The problem only showed up when I checked which authentication middleware the agent had imported.

Our codebase had two: a v1 middleware backed by MongoDB and a v2 middleware backed by MySQL, which we had spent the previous quarter migrating.

New endpoints were supposed to use v2. The agent had used v1 for all three. Tests passed because user records still existed in both databases (that was the point of the migration), and the v1 middleware happily authenticated them. The code worked. But every new endpoint we shipped was reinforcing the legacy auth path we had just spent a quarter trying to retire.

I caught it on the second read. Twenty minutes after the comments, the engineer fixed it and reopened the PR. The third reviewer probably wouldn't have caught it. The migration timeline lived in a Slack thread from six months earlier. The rule that "new endpoints use v2" lived in my head.

This kind of catch is the slow-burn version of why AI changed my job as a tech lead. Code generation got faster. My review queue got longer. The hardest reviews were the ones where everything looked right, and the only thing wrong was something that lived in the team's collective memory rather than in the diff.

This handbook is about what we did to fix that. It's the story of how we went from drowning in clean-looking PRs to running a custom AI PR reviewer that catches a meaningful share of these mistakes before any human is pulled in. The fix turned out to be less about buying a better tool and more about moving the team's memory into a place the AI could actually read.

The lessons should transfer whether your team uses Claude Code, Cursor, Cline, GitHub Copilot, or any combination. The structure matters more than the tool.

Table of Contents

• The Old Bottleneck, and the One AI Created

• What the New Review Work Actually Looks Like

• Why I Did Not Just Buy a Tool

• The Realisation: Move the Rules Into the Codebase

• Two Files That Changed Everything: AGENTS.md and CLAUDE.md

• Where Per-Service Memory Files Earn Their Keep

• What This Looks Like on Disk

• Generated Documentation as a Side Effect

• Building the PR Review Command

• Guardrails: Read-Only by Default

• The Compounding Loop That Made the Real Difference

• Starting From Zero on an Existing Project

• What Still Needs Human Review

• A Two-Week Setup Plan

• What Is Working, What I Am Still Improving

• Sources

The Old Bottleneck, and the One AI Created

To understand why this fix was needed, it helps to remember what reviewing code looked like a couple of years ago.

Back then, the slow part was upstream of the PR. A ticket would land, and before anyone could open a branch, there was a long preamble of context-gathering.

Junior engineers needed time to understand what the change was for. Senior engineers had to explain business rules and architectural decisions. Tickets sat in "ready" columns for days while someone with the right context made themselves available. Then the writing itself took time, because typing real code is slower than typing comments about it.

That bottleneck mostly dissolved when the team got serious about AI-assisted development. Engineers used the agent to read the codebase, ask clarifying questions, draft an implementation plan, and produce a working branch in hours instead of days. Tickets moved through the queue faster. Junior engineers shipped more without blocking on senior availability. From the outside, this looked like an unambiguous win.

But the bottleneck didn't disappear. It moved.

Within a few weeks of widespread AI adoption, my review queue had doubled. Then tripled. Engineers were opening PRs faster than I could read them.

The PRs themselves looked clean: well-formatted, with sensible variable names, passing tests, and AI-generated descriptions that read better than most human-written ones.

On the surface, this was great. In practice, it was creating a different kind of pain. I was the senior engineer who knew which patterns mattered and which paths through the codebase were the right ones, and I was the bottleneck. The team's velocity was now capped by my reading speed.

The CircleCI 2026 State of Software Delivery report confirmed I was not alone. Drawing on more than 28 million CI workflow runs across over 22,000 organisations, the report showed feature branch throughput had grown 59% year over year, the largest jump CircleCI had ever measured. Main branch throughput, where code actually gets promoted to production, fell by 7% for the median team in the same period. Build success rates dropped to 70.8%, the lowest in five years.

The pattern was consistent across the industry. AI accelerated writing. The rest of the system absorbed the cost.

So the question for me, as a tech lead, became concrete: how do I unblock myself without lowering the bar?

What the New Review Work Actually Looks Like

Before I explain the fix, it helps to know what kinds of issues were actually piling up. They weren't the dramatic kind. None of them would crash production. They were small, recurring, and looked plausible at a glance.

Take the simplest case I kept catching. An engineer would ask the agent to add a delete button on a new screen. The button needed to call our existing backend delete endpoint. Instead of reusing the hook the team already had for that endpoint, the agent would write the fetch call inline.

The code worked. The tests passed. But a week later, when someone changed the backend response shape, only one of the two call sites got updated.

That kind of duplication doesn't show up in a code review unless the reviewer happens to remember that a hook exists.

Another example I saw constantly: the agent comparing a status field against the literal string "completed" instead of using the Status.Completed enum that the rest of the services used. The code ran. The tests ran. The next refactor of the enum quietly skipped the file. After a few days, someone would spend half a day debugging a state machine that was working fine until the agent's literal silently fell out of sync.

These were two-minute fixes once spotted, but spotting them took me a reasonable time per PR. The friction wasn't the difficulty. It was the repetition.

The pattern repeated across larger problems, too.

I once asked an agent to build an event creation wizard. The wizard needed several dropdowns and one new component.

We have a design system folder where shared UI components live, and the rule on the team is simple: check there first, and if you build something new, register it there.

The agent had no way to know that. It only loaded the wizard's own files, so it never opened the design system folder. It generated brand new dropdowns inline, with APIs that were almost identical to the ones we already had. The new component went straight into the wizard rather than into the design system. CI passed. The wizard worked. We caught the duplication in human review, but it was the kind of catch that depended entirely on a reviewer who happened to know the design system existed.

The same pattern hit in one of the repos I was looking at for backend architecture. Backend follows a strict four-layer pattern: route, controller, app, repo. Controllers must never call repository functions directly. That rule keeps authorisation centralised, business logic testable, and database concerns isolated.

One PR I reviewed had the agent calling repo functions straight from a controller, skipping the app layer entirely. The code worked. The tests passed because the agent had also written tests against the new shape. But it broke a discipline the team had spent years building. If that PR had landed, the next AI-assisted PR could have used it as a template, and the layering would have eroded one diff at a time.

The common thread is that all of these mistakes had something written down somewhere, in code, in a Slack thread, in a senior engineer's head, that would have prevented them. The information existed. The agent just couldn't see it.

Why I Did Not Just Buy a Tool

The obvious next move was to install one of the AI PR reviewers that flooded the market in 2026.

I evaluated several. Anthropic launched Claude Code Review in March 2026, billed on token usage and averaging \(15 to \)25 per review. CodeRabbit Pro charges \(24 per developer per month on annual billing, or \)30 per developer per month on monthly billing, with seats counted against developers who actually open PRs. Greptile in March 2026 moved to a base-plus-usage model at $30 per seat per month, including 50 reviews, after which each additional review costs a dollar. GitHub announced that all Copilot plans will transition to usage-based billing on June 1, 2026, with code reviews consuming both AI Credits and GitHub Actions minutes from that date.

For a small team with low PR volume, none of these is a dealbreaker. For a larger team running heavy AI-assisted development, the costs compound fast. A 10-person team running five PRs each per day blows through Greptile's included reviews in a single week. CodeRabbit Pro at \(24 per seat scales linearly with developers. The premium Claude Code Review at \)15 to $25 per PR is the most expensive option per review by an order of magnitude.

I looked at the cost numbers, but cost wasn't actually the deciding factor. The deciding factor was that none of these tools would have caught the problems I just listed.

A generic reviewer wouldn't have caught the v1/v2 middleware. It had no way to know v2 was the canonical path. A generic reviewer wouldn't have caught the duplicate dropdowns. It had no way to know our design system existed. A generic reviewer wouldn't have caught the bypassed architecture. It had no way to know that controllers must not call repositories.

The information that lets a reviewer flag any of these is exactly the information that lives in the team's head, not in any tool's default prompt.

The better-rated tools support custom rules, and that's where I started to see the real shape of the problem. Once you are configuring custom rules, you've already accepted that the value is in the rules. The tool is just whatever runs them.

This raised a different question: if the rules are the product, why pay per seat or per review for someone else's wrapper around them?

This is what made me change direction.

The Realisation: Move the Rules Into the Codebase

Once I started thinking of the rules as the product, the path forward got clearer.

I asked myself a simple question: what was I actually doing in code review that the AI was not? The answer turned out to be the same thing, over and over. I was typing review comments that captured a piece of the team's memory.

"Use the Status enum, not a string literal." "There is already a hook for this in /hooks/useDeleteItem." "Controllers must not import from the repo layer; route this through the app layer." "Check the design system folder before creating new components."

Each of those comments was knowledge that lived in my head and arrived in the codebase one PR comment at a time. None of it was available to the agent the next time it generated a similar PR.

So the fix was not to buy a smarter reviewer. The fix was to write the rules down in a place every agent on the team would read before any review happened.

If I had typed "use the enum, not a literal" three times in three different PRs, that was a rule the agent should know about from now on. If I had pointed at the design system folder for the fourth time, that was a rule. If I had explained the four-layer architecture twice in PR comments, that was a rule.

I needed somewhere to put these rules. That turned out to be a less obvious decision than I expected.

Two Files That Changed Everything: AGENTS.md and CLAUDE.md

If you start looking into how to give an AI agent a persistent project context, you run into two competing conventions almost immediately.

The first is AGENTS.md, an open standard that has gathered real momentum. According to InfoQ, by mid-2025, the format had already been adopted by more than 20,000 GitHub repositories and was being positioned as a complement to traditional documentation: machine-readable context that lives alongside human-facing files like README.md.

The standard's own site reports it is now used by more than 60,000 open-source projects and has moved to stewardship under the Agentic AI Foundation, which sits inside the Linux Foundation. The format is supported by OpenAI Codex, GitHub Copilot, Google Gemini, Cursor, and Windsurf, among others.

The second is CLAUDE.md, which is Anthropic's convention for Claude Code. The Claude Code documentation describes two complementary memory systems: CLAUDE.md, where you write the persistent context yourself, and an auto-memory mechanism that lets Claude save its own notes from corrections and observed patterns. By default, Claude Code reads CLAUDE.md, not AGENTS.md.

This split mattered for us because half the team uses Claude Code and the other half uses Cursor. We had two practical options: maintain both files with the same content (and accept the duplication), or symlink one filename to the other so both ecosystems read the same source of truth. We went with the symlink. It's one less thing to drift.

The next question was what to actually put in the file. After a few iterations, here's the shape that worked. Think of it as a briefing document for a new engineer who has read no code and seen no Slack threads. The minimum content was:

• The tech stack (languages, frameworks, package manager)

• The project structure, especially important for our monorepo

• Where shared utilities, components, and helpers live, and the rule that new code should reuse them before creating new versions

• Architectural patterns the project follows, with file path examples

• Anti-patterns and what to do instead

• Test conventions and where good examples live

• Pointers to deeper documentation when more detail is needed

Two practical rules emerged from the first month of using these files.

Keep them lean: There is a counterintuitive failure mode with long instruction lists: the agent doesn't just skip the new ones at the bottom. The average compliance across all of them drops. A bloated memory file becomes a memory file that the agent skims. If a section runs more than a paragraph or two, move it to a separate document and link to it.

Phrase rules as imperatives, not aspirations: "Controllers must not call repositories. Route through the app layer." beats "Try to keep controllers thin." The first is testable. The second is decorative.

That was the entry point. But a single root-level file was not enough for a monorepo with multiple services and frontends, which led to the next decision.

Where Per-Service Memory Files Earn Their Keep

A single AGENTS.md at the root of a monorepo collapses under its own weight pretty quickly. Each service in our codebase has its own architecture, conventions, and business rules. Trying to fit all of that into one file produced a long document that the agent treated as background noise, and we were back to the bloat problem from the previous section.

The pattern that worked: every service or app gets its own AGENTS.md at its root, and the project-level AGENTS.md becomes an index that points to them.

A per-service AGENTS.md covers things like:

• The architecture for this service (the four-layer pattern, the directory layout)

• Naming conventions specific to this service

• Test patterns and where good examples live

• Business rules that this service is responsible for

• Inter-service contracts and what other services consume from this one

• Pointers to deeper docs in docs/

• A "Lessons learned" section, which I'll come back to in the section on the compounding loop

The same lean rule applies. Keep it short, point at examples, and phrase guidance as imperatives.

The reason this works mechanically is that the agent loads the right files for the work at hand. When an engineer asks the agent to change something in backend/, the agent reads the project-level AGENTS.md, sees that work in backend/ should be guided by backend/AGENTS.md, and loads that file. It doesn't load the frontend's AGENTS.md, because that work is somewhere else. The context window stays focused on what's relevant.

Without this split, you have two bad options. Either you put everything in the root file, where the agent ignores most of it, or you put nothing in the root file, where the agent has no team context at all. The per-service split gives you both depth and signal.

But these files only work if the deeper docs they point to actually exist, which is where the next piece of the system came in.

What This Looks Like on Disk

Before going further, it helps to see the whole structure laid out. Here's the shape we settled on for our monorepo. The exact folder names follow Claude Code's conventions. If you use Cursor, it would be .cursor/, and if you use Cline, it would be .clinerules – but the shape transfers directly.

project-root/
├── AGENTS.md                       # symlink to CLAUDE.md
├── CLAUDE.md                       # root memory file
├── README.md                       # human-facing project readme
│
├── .claude/                        # tool-specific config folder
│   ├── README.md                   # explains the .claude/ layout
│   ├── settings.json               # permissions and guardrails
│   ├── agents/                     # specialised subagents (optional)
│   ├── commands/                   # slash commands engineers run
│   │   ├── review-pr.md            # the PR review command
│   │   └── plan-feature.md         # implementation plan command
│   ├── hooks/                      # lifecycle hooks (optional)
│   ├── pr-rules/                   # rule files for PR review
│   │   ├── common.md               # rules that apply to every PR
│   │   ├── frontend.md             # rules for frontend changes
│   │   ├── backend.md              # rules for backend changes
│   │   ├── service-a.md            # rules for service-a
│   │   └── service-b.md            # rules for service-b
│   └── skills/                     # reusable workflows
│
├── frontend/
│   ├── AGENTS.md                   # frontend conventions
│   ├── docs/
│   │   ├── overview.md
│   │   ├── architecture.md         # routing, state, data layer
│   │   ├── design-system.md        # design system reference
│   │   └── testing.md              # test conventions
│   └── src/
│
├── backend/
│   ├── AGENTS.md                   # the four-layer pattern
│   ├── docs/
│   │   ├── overview.md
│   │   ├── architecture.md         # route -> controller -> app -> repo
│   │   ├── auth.md                 # v1 vs v2 middleware
│   │   ├── business-rules.md
│   │   └── integrations.md
│   └── src/
│
├── service-a/
│   ├── AGENTS.md
│   ├── docs/
│   │   ├── overview.md
│   │   ├── business-rules.md
│   │   └── integrations.md
│   └── src/
│
└── service-b/
    ├── AGENTS.md
    ├── docs/
    │   ├── overview.md
    │   ├── business-rules.md
    │   └── integrations.md
    └── src/

A few things worth pointing out:

The .claude/ folder uses standard subfolder names: commands, agents, hooks, skills. These follow Claude Code's plugin model, but most modern AI coding tools have similar slots. Following the conventions makes the structure recognisable to anyone on the team and lowers the cost of switching tools later.

The pr-rules/ folder isn't a standard convention. It's a folder we created to hold per-area review rules that the PR review command loads selectively. You don't have to call it pr-rules – the name matters less than having one place where review rules live.

Each service has its own AGENTS.md plus a docs/ folder. The root AGENTS.md is short and acts as an index. It tells the agent things like "if you touch files in backend/, also read backend/AGENTS.md first." The per-service file then points at the deeper docs as needed.

Generated Documentation as a Side Effect

Setting up per-service AGENTS.md files surfaced a problem I had been quietly avoiding. Most of our services didn't have decent documentation. Not API reference material, which lives in code, but the higher-level "what does this service do, what business rules does it enforce, what does it consume and produce" information that lives in nobody's head except the original author's.

The honest reason was that writing this kind of documentation by hand had never paid back the time it took. By the time the doc was finished, half of it was already stale.

So I tried something I wouldn't have considered earlier. I used the AI itself to generate a first draft for each service. I pointed the agent at each service's code and asked it to produce a docs/ folder with a specific structure: an overview, a list of business rules, an integrations document, a domain model, and any quirks worth knowing. The agent read the code, traced the call paths, and wrote a draft.

I then reviewed the output by hand, corrected the things it got wrong, and committed the result. The first drafts were 70-80% correct. The remaining 20-30% was where the agent had made plausible but wrong inferences, and those were exactly the cases where human review mattered.

The generated docs ended up serving two audiences. The agent uses them when reasoning about changes, which means it has real context for the service it's touching rather than guessing from local files. And new engineers use them on their first day, which has cut our onboarding time noticeably.

We used to write onboarding documents that drifted out of date within months. These docs stay closer to current because the agent reads them on every PR, and any drift gets surfaced when the agent gives wrong advice based on stale information.

The pattern that works is to keep the per-service AGENTS.md short and pointing at the docs, rather than duplicating their content. AGENTS.md is the always-loaded index. docs/ holds the details. The agent loads the relevant doc on demand when the task calls for it.

With the rules in place and the docs in place, I had everything I needed to build the actual reviewer.

Building the PR Review Command

This is the piece that most directly unblocked my queue.

This command didn't appear out of nowhere. It started as the checklist I was running through in my head every time I opened a PR. I was reviewing every change manually, leaving the same comments, flagging the same patterns. So I wrote that checklist down, expanded it with references to the per-service docs for the harder rules, and turned it into a command anyone on the team could run.

Then I handed it to the engineers and changed the rule: run this on your own branch before marking the PR ready for review. That single shift moved the work from after the PR was opened to before. Engineers now catch 90-95% of the blockers, improvements, and nice-to-haves on their own machine, fix them locally, and only then push the change.

The PR description includes the AI's summary, so when anyone opens the PR, they can see the reviewer's green signal at the top before even reading the diff.

GitHub stays clean. The conversation on the PR becomes about the things that actually need a human, not the recurring stuff the team already knows how to fix.

The command lives in .claude/commands/review-pr.md. Here's a generalised version. Your tool's command structure may differ, but the shape is what matters.

# Review PR

Review the current branch's PR. Be direct. Cite `file:line`. Surface real issues,
no padding.

## 1. Scope the diff

Run, in order:

    gh pr view --json number,title,body,headRefName 2>/dev/null || true
    git fetch origin main
    git log --no-merges origin/main..HEAD --oneline
    git diff origin/main...HEAD --stat
    git diff origin/main...HEAD

Read the PR body. Note the stated intent. Every change should trace to it. Flag
anything that does not.

Use `...` (three dots) for the diff. It compares against the merge base and
excludes commits brought in by merging main.

## 2. Load rules

Always read `.claude/pr-rules/common.md`.

Then read the per-area file for each workspace touched in the diff:

| Workspace path | Rules file                      |
| -------------- | ------------------------------- |
| `frontend/**`  | `.claude/pr-rules/frontend.md`  |
| `backend/**`   | `.claude/pr-rules/backend.md`   |
| `service-a/**` | `.claude/pr-rules/service-a.md` |
| `service-b/**` | `.claude/pr-rules/service-b.md` |

For non-trivial changes, follow doc pointers inside the rules files (for
example, `backend/AGENTS.md`, `backend/docs/architecture.md`).

Apply every entry under each file's "Lessons learned" section as a check.

## 3. Output

Use exactly this format.

    ## Summary
    <one paragraph: what the PR does, whether it matches the stated intent>

    ## Blocking
    - [file:line] issue, why it blocks

    ## Should fix
    - [file:line] issue

    ## Nice to have
    - issue

    ## Verified
    - what was checked and looks good

If nothing blocks, say so. Do not manufacture concerns.

If you find an issue worth remembering for future PRs, suggest the bullet to
add to the relevant rules file's "Lessons learned" section. Do not edit the
rules file yourself, leave that to the human.

A few of the design choices in this command turned out to matter more than I expected.

The structured output format (Summary, Blocking, Should fix, Nice to have, Verified) keeps the review easy to scan and easy to paste into a PR description. The "Verified" section is the most underrated of the five: it tells the human reviewer what the AI already checked, so they can spend their attention elsewhere. Without it, the human reviewer ends up doing the same checks twice.

The instruction to be direct and stop padding does real work. Without it, AI reviewers tend to manufacture concerns to look thorough, which trains engineers to skim past the bot. Telling it explicitly to say "nothing blocks" when nothing blocks made the signal-to-noise ratio of the output much better.

The "suggest a bullet for the rules file" instruction at the end is the heart of the whole system, and I'll explain why in the section on the compounding loop. The key constraint here is that the agent suggests the bullet but doesn't commit to it. A human evaluates whether it's general enough to be a rule, and only then adds it to the file. That manual step is what keeps the rules sharp instead of bloated.

With each PR, if humans fix something or the AI suggests something, you keep adding those to your MD files and keep improving your agents for the future. The result compounds quickly.

One more thing here: the diff-scoping commands are all read-only. The command shouldn't be able to push, edit PRs, or close anything. Which is the next piece of the system.

Guardrails: Read-Only by Default

Giving an AI agent broad permissions on your codebase is a security incident waiting to happen. Even if you trust the model to behave, an LLM occasionally does unexpected things, and a fast-moving agent on an unrestricted shell can cause damage in seconds.

The fix is a settings.json (in Claude Code – other tools have their own equivalents) at the root of .claude/ that explicitly declares what the agent can and can't do. The deny list matters more than the allow list, and a good one is organised around four categories of risk.

The first is secrets and configuration. Any read against anything that appears to be a credential is blocked. That covers .env files of every variant (.env, .env.local, .env.production, .env.test, and so on), .npmrc, .netrc, .pgpass, id_rsa, id_ed25519, *.pem, *.key, *.p12, **/credentials.json, **/secrets.json, **/.aws/**, **/.ssh/**, **/.gcloud/**, and **/.kube/**. Environment dumps are blocked too: env, printenv, set, export. The agent has no legitimate reason to read or echo any of these, ever.

The second is destructive Git operations. The agent can read Git history but can't rewrite or push it. Blocked: git push, git commit, git revert, git cherry-pick, git merge, git rebase, git reset --hard, git tag. Allowed: git fetch, git status, git log, git diff, git show, git branch, git rev-parse, git merge-base, git config --get.

The third is write operations on PRs and issues. The agent can read your GitHub state but can't act on it. Blocked: gh pr create, gh pr edit, gh pr merge, gh pr close, gh pr comment, gh pr review, gh issue create, gh issue edit, gh issue close, gh issue comment, gh release create, gh repo create, gh repo edit, gh repo delete. Allowed: gh pr view, gh pr list, gh pr diff, gh pr checks, gh issue view, gh issue list, gh release view.

The fourth is workflow and automation control. These are the surfaces where a compromised or misled agent could do the most damage. Blocked: gh workflow run, gh run rerun, gh run cancel, gh secret, gh variable, gh auth, gh ssh-key, gh gpg-key, and the unrestricted gh api.

For shell commands the agent legitimately needs to run, like build and test commands, allowlist specific patterns: pnpm test, pnpm lint, pnpm format:check, pnpm build, pnpm vitest. Anything outside the allowed list requires human confirmation. These are your own settings – I've just mentioned what I prefer.

The pattern is simple: read-only by default, write-allowed only for the specific commands you have explicitly approved. The agent can investigate, plan, and recommend. It can't ship.

With the structure in place and the guardrails set, the system started doing its job. What I didn't expect was how much better it would get over the months that followed.

The Compounding Loop That Made the Real Difference

When we started, the AI reviewer was useful but not transformative. It caught some obvious issues, missed plenty of subtle ones, and produced a fair amount of noise.

The first month, my review burden dropped by 35%. The time I was spending on PR checking was reduced to 1/3, almost. Decent, not life-changing.

What changed over time wasn't the tool. It was the rules.

Every time a PR creator and reviewer caught something the AI had missed, we were adding bullets to the relevant rules file. Every time the AI flagged something useful that turned out to be a recurring pattern, the agent's own suggestion at the end of the review went into the file.

After a few days, the rules files had grown into something that captured a meaningful fraction of the team's collective review knowledge, written down in a place every agent on the team would read.

The catch rate went up. The noise went down because the rules also said what was acceptable and what we already considered solved. New engineers stopped getting the same comments on their first three PRs because the AI caught the comments first. Engineers joining the team didn't have to absorb the conventions through six months of review feedback. They installed the project, opened it in their editor, and the agent already knew.

This is the part most teams miss when they evaluate AI PR review tools. They look at the catch rate today and decide whether the tool is worth the price. The catch rate today isn't the right number. The right number is what the catch rate looks like in six months, after the rules file has absorbed every recurring mistake your team has made.

A single rule written down today saves a small amount of review time. Over a hundred PRs, it saves more. After a year, the rules file is a written-down version of a tech lead's accumulated taste. We've switched between Claude Code, the GitHub Copilot CLI, and Cursor for various tasks during this period. The AI tool changes, but the rules file in the repo stays the same.

The discipline that makes this work is treating the rules file as living documentation. Every recurring review comment is a candidate for promotion into the file. If you catch yourself typing the same feedback in two different PRs, that's a rule that belongs in pr-rules/. The "suggest a bullet" instruction in the review command is what makes this practical: the AI does the typing, the human does the deciding.

This is also what made me realise the system was worth the time it took to set up. The PR review command, on its own, is useful but unremarkable. The compounding loop is what turns it into infrastructure.

Starting From Zero on an Existing Project

If you've read this far and feel like the gap between your project and what I just described is a sprint of work, that's the most common reaction. It's also not correct.

The blank AGENTS.md is intimidating, especially on an existing codebase. You know your team has a thousand conventions, and writing a thousand rules sounds like a project that takes weeks before it produces any value.

The honest answer is that you can't write all the rules up front, and you shouldn't try. The first version of any of these files should take an afternoon, not a sprint.

Here's how I would actually start.

Run /init (or your tool's equivalent). In Claude Code, /init scans the project, infers the obvious shape (language, framework, entry points, build commands), and writes an initial CLAUDE.md. The output is a starting point, not a finished file. Read it, delete most of what it generates, and keep the bones.

Then add three things, each one bullet long.

First, an architecture rule. Pick the single most important convention your team enforces. For us, that was the four-layer pattern. The bullet was: "Controllers must not call repository functions directly. They must go through the app layer."

Second, a discoverability rule. Pick the single most important shared resource the team has, the one new code is most likely to duplicate. For us, that was the design system. The bullet was: "Before creating a new UI component, check /src/design-system/ first."

Third, a "do not touch" rule. Pick the single most dangerous file or area in the codebase. Auth, billing, or migrations whichever has the most production risk. The bullet was: "Do not modify files in /auth/ without human approval."

That's enough to start. Three rules, ten minutes of writing, and most of your team's recurring AI mistakes start to drop.

If even three rules feels like too much, start with one. Pick a single line that matters in your codebase and write it down.

"No any types in TypeScript." "Always use the enum, never compare against the string literal." "Run the linter before opening a PR." It doesn't have to be sophisticated. It doesn't have to cover edge cases. It just has to capture one piece of judgement that lives in your head today and would otherwise stay there.

Tomorrow, add another. The first week, you might catch 5% of the recurring mistakes. By 20 or 30 PRs in, you might catch 20-30%. The rules file doesn't need to be impressive on day one. It needs to exist and keep growing.

This is the compounding effect I'll come back to soon, and it's the reason this approach works on real projects rather than just in theory.

From there, the file grows the same way it would grow for any team. Every review catch becomes a candidate rule. After a few weeks, you have ten or fifteen rules. After a few months, you have a real review system.

The mistake is trying to write the perfect file on day one. The right file is the one you start with and keep editing.

What Still Needs Human Review

This system doesn't replace human review, and it shouldn't be allowed to.

The AI reviewer catches what the rules describe, plus a fair number of obvious things it would have spotted anyway. It doesn't catch problems that depend on context the rules don't capture. It doesn't catch product judgement. It doesn't catch the question of whether the change should have been built at all.

It also has an important blind spot when reviewing AI-authored code. The reviewer shares the same training data and reasoning patterns as the agent that wrote the code. If the original agent missed the v1/v2 distinction because it had no way to see the migration timeline, an AI reviewer reading the same diff has the same problem. Two AIs in a review loop are not two independent reviewers. They share blind spots.

That is why the AI reviewer in this setup never approves a PR. It produces a structured review that goes into the PR description. A human still reads the change and approves it. The AI is the first pass, not the gate.

Accountability also has to live with a human. When something the AI approved breaks production, someone has to own the post-mortem and decide what changes are needed for next time. The AI can't be that person. What it can do, well, is reduce the stack of small mistakes a human reviewer has to find before they get to the harder questions.

A Two-Week Setup Plan

If you want to set this up for your own team, here's a concrete plan that fits in a couple of weeks. None of this needs to happen in a single push.

Day 1: Bootstrap the memory file.

Run /init (or your tool's equivalent) at the root of the project. Read the generated CLAUDE.md (or AGENTS.md). Delete most of it. Keep the tech stack and project structure sections.

Add the three rules from the previous section: one architecture rule, one discoverability rule, and one "do not touch" rule. Decide whether you want both files or a symlink.

Day 2: Add per-service files for your highest-risk areas

Pick the two or three areas of the codebase that change most often or carry the most risk. Add an AGENTS.md to each, following the same lean pattern. Include the architectural pattern for that area, the naming conventions, where to find good test examples, and pointers to any existing docs. Skip anything that doesn't need to be there yet.

Day 3: Set up the directory structure and guardrails

Create a .claude/ folder (or your tool's equivalent) at the root, with commands/ and pr-rules/ subfolders. Add a settings.json with the deny list categories from the guardrails section. Test that the agent can't read a .env file, run git push, or create a PR. If any of those work, fix the settings before doing anything else.

Day 4: Write the PR review command

Adapt the command in this article to your structure. Include the diff scoping, the rule loading, the output format, and the "suggest a new rule" instruction at the end. Run it on a branch you've already merged, and tune the output until it's useful.

Day 5: Run it on real PRs

Have one or two engineers run the command on their next PRs before opening them. Read the output. Note what it caught, what it missed, and what was noise. Add the missing catches to the rules files. The first week is mostly tuning.

Week 2: Roll out and document

Once the command produces useful output reliably, ask the whole team to run it before opening PRs and paste the output into the PR description. Add a short section to your contributing guide explaining the workflow. Set a recurring item in your team's rituals to review the rules files monthly and trim anything that has gone stale.

That gets you to a working system. From there, the maintenance is incremental. Every recurring review comment becomes a candidate rule. Every architectural decision becomes a candidate update to the relevant AGENTS.md. The system improves as a side effect of the work the team is already doing.

What Is Working, What I Am Still Improving

Here's my honest assessment after a few months of running this:

What's Working

My review burden is meaningfully smaller. Engineers fix most of the easy mistakes before I see the PR. The "Verified" section of the AI's output tells me what to skip past. New engineers ramp faster because the conventions live in a place their tooling reads. The rules files have grown into something I would actually use to onboard someone new.

What Isn't Finished

The AI still misses problems that depend on context, and the rules don't capture them. The rules files grow, but they also need pruning, and we haven't been disciplined about that.

We're still figuring out how to handle rules that apply only conditionally. Docs are helping in that case, but we need to keep those up to date. And no system survives a determined engineer who skips the workflow or docs when they're in a rush.

There's no shortcut here. The work is real, ongoing, and mostly about discipline. The discipline is treating your codebase as something the AI needs to learn, and treating every recurring review comment as something that should be written down once instead of typed thirty times. If you're willing to do that, the tools take care of the rest.

If you take three things from this article, take these.

1. First, don't pay for a generic reviewer to do a job your codebase needs to inform. Generic reviewers catch generic problems. Most of your real review work is specific to your team.

2. Second, put the rules in a file the AI reads, not in your head. AGENTS.md, CLAUDE.md, per-service files, per-area rules files. Pick a structure and stick to it.

3. Third, treat every human review catch as a chance to update the rules. The compounding effect over months is the entire point. A review system that improves itself is worth more than any single tool.

That's the system. It took a couple of weeks to build the foundation and a few months for the rules to mature. It costs very little to run, and it has done more for our PR throughput than any tool I evaluated.

Sources

• CircleCI's 2026 State of Software Delivery report, analysing more than 28 million CI workflows from over 22,000 organisations: https://circleci.com/resources/2026-state-of-software-delivery/

• CircleCI's blog post detailing the year-over-year throughput numbers, including the 59% feature branch growth and the main branch decline: https://circleci.com/blog/five-takeaways-2026-software-delivery-report/

• GitHub announcement of Copilot's transition to usage-based billing on June 1, 2026: https://github.blog/news-insights/company-news/github-copilot-is-moving-to-usage-based-billing/

• GitHub changelog confirming Copilot code review will start consuming GitHub Actions minutes on June 1, 2026: https://github.blog/changelog/2026-04-27-github-copilot-code-review-will-start-consuming-github-actions-minutes-on-june-1-2026/

• AGENTS.md, the open standard's official site, including its stewardship under the Agentic AI Foundation and the Linux Foundation: https://agents.md/

• Anthropic's Claude Code documentation on the memory system, including CLAUDE.md, auto memory, and the /init command: https://code.claude.com/docs/en/memory

• Anthropic's Claude Code GitHub Actions documentation, including notes on token-based billing and recommended cost controls: https://code.claude.com/docs/en/github-actions

• CodeRabbit's pricing documentation, confirming the per-developer-per-month seat model: https://docs.coderabbit.ai/management/plans

• Greptile's March 2026 pricing announcement, introducing the base-plus-usage model at $30 per seat per month with 50 included reviews: https://www.greptile.com/blog/greptile-v4

• HumanLayer's write-up on writing a good CLAUDE.md, including data on instruction-following degradation: https://www.humanlayer.dev/blog/writing-a-good-claude-md

The explanation everyone reaches for is that AI replaced it. That's partly true. But it misses the structural problem underneath: every time a developer asks Claude or ChatGPT to write code, the knowledge that shaped the answer disappears.

The GitHub discussion where someone spent two hours documenting why cursor-based pagination beats offset for live-updating datasets. The Stack Overflow answer from 2019 where one engineer, after a week of debugging, documented exactly why that approach fails under concurrent writes.

The AI consumed all of it. The humans who produced it got nothing — no citation in the codebase, no signal that their work mattered.

Over time, those people stopped contributing. Stack Overflow isn't dying because it's bad. It's dying because AI extracted its value and the feedback loop that kept humans contributing broke down.

This tutorial builds a tool that puts that loop back together. proof-of-contribution is a Claude Code skill that links every AI-generated artifact back to the human knowledge that inspired it — and surfaces exactly where the AI made choices with no human source at all.

I'll show you how to install proof-of-contribution, how to record your first provenance entry, how to use the spec-writer integration that makes Knowledge Gaps deterministic, and how to run poc.py verify — a static analyser that detects gaps without a single API call.

Table of Contents

1. What You Will Build

2. Prerequisites

3. Quickstart in 5 Minutes

4. How the Tool Works

5. How to Install proof-of-contribution

6. How to Scaffold Your Project

7. How to Record Your First Provenance Entry

8. How to Use import-spec to Seed Knowledge Gaps

9. How to Trace Human Attribution

10. How to Verify with Static Analysis

11. How to Enable PR Enforcement

12. Where to Go Next

What You Will Build

proof-of-contribution is a Claude Code skill with a local CLI. Together they give you:

• Provenance Blocks: Claude appends a structured attribution block to every generated artifact, listing the human sources that inspired it and flagging what it synthesized without any traceable source.

• Knowledge Gaps: the parts of AI-generated code that have no human citation, surfaced before they become production incidents

• poc.py trace: a CLI command that shows the full human attribution chain for any file in thirty seconds

• poc.py import-spec: bridges proof-of-contribution with spec-writer, seeding knowledge gaps from your spec's assumptions list before the agent builds anything

• poc.py verify: a static analyser that cross-checks your file's structure against seeded claims using Python's AST. Zero API calls. Exit code 0 means clean, exit code 1 means gaps found — wires directly into CI

• A GitHub Action: optional PR enforcement that fails PRs missing attribution, for teams that want a standard

The complete source is at github.com/dannwaneri/proof-of-contribution.

Prerequisites

This is a beginner-to-intermediate tutorial. You should be comfortable with:

• Command line basics: navigating directories, running scripts

• Git: basic commits and PRs

• Python 3.8 or higher: the CLI is pure Python with no dependencies

You will need:

• Python installed: check with python --version or python3 --version

• Git installed: check with git --version

• Claude Code (or any agent that supports the Agent Skills standard — Cursor and Gemini CLI also work)

There's no database to install. No API keys. No paid services. The default storage is SQLite, which Python includes out of the box.

Quickstart in 5 Minutes

If you want to try the tool before reading the full tutorial, here are the five commands that take you from zero to your first gap detection:

Mac and Linux:

# 1. Install
mkdir -p ~/.claude/skills
git clone https://github.com/dannwaneri/proof-of-contribution.git \
  ~/.claude/skills/proof-of-contribution

# 2. Scaffold your project (run in your repo root)
python ~/.claude/skills/proof-of-contribution/assets/scripts/poc_init.py

# 3. Record attribution for an AI-generated file
python poc.py add src/utils/parser.py

# 4. Detect gaps via static analysis
python poc.py verify src/utils/parser.py

# 5. See the full provenance chain
python poc.py trace src/utils/parser.py

Windows PowerShell:

# 1. Install
New-Item -ItemType Directory -Force -Path "$HOME\.claude\skills"
git clone https://github.com/dannwaneri/proof-of-contribution.git `
  "$HOME\.claude\skills\proof-of-contribution"

# 2. Scaffold your project
python "$HOME\.claude\skills\proof-of-contribution\assets\scripts\poc_init.py"

# 3. Record attribution
python poc.py add src\utils\parser.py

# 4. Detect gaps
python poc.py verify src\utils\parser.py

# 5. See the full provenance chain
python poc.py trace src\utils\parser.py

That's the whole tool. The sections below walk through each step in detail with real terminal output at every stage.

How the Tool Works

Before you install anything, you need a clear mental model of what proof-of-contribution actually does — because the most important part isn't obvious.

The Archaeology Problem

Here's a scenario that happens on every team using AI-assisted development.

A developer joins. They go through six months of AI-generated codebase. They hit a bug in the pagination logic — cursor-based, unusual implementation, nobody remembers why it was built that way. The original developer has left.

Old answer: two days of archaeology. git blame points to a commit message that says "fix pagination." The commit before that says "implement pagination." Dead end.

With poc.py trace src/utils/paginator.py, that same developer sees this in thirty seconds:

Provenance trace: src/utils/paginator.py
────────────────────────────────────────────────────────────
  [HIGH]  @tannerlinsley on github
          Cursor pagination discussion
          https://github.com/TanStack/query/discussions/123
          Insight: cursor beats offset for live-updating datasets

Knowledge gaps (AI-synthesized, no human source):
  • Error retry strategy — no human source cited
  • Concurrent write handling — AI chose this arbitrarily

They now know where the pattern came from and — critically — which parts have no traceable human source. The concurrent write handling is where the bug lives. The AI made a choice nobody reviewed.

That's what this tool does. Not enforcement first. Archaeology first.

How Knowledge Gaps Are Detected

The obvious assumption is that Claude introspects and reports what it doesn't know. That assumption is wrong. LLMs hallucinate confidently. An AI that could reliably detect its own knowledge gaps wouldn't produce them.

The detection mechanism is a comparison, not introspection.

When you use spec-writer before building, it generates a spec with an explicit ## Assumptions to review section — every decision the AI is making that you didn't specify, each one impact-rated. That list is the contract.

When you run poc.py import-spec spec.md --artifact src/utils/paginator.py, those assumptions get seeded into the database as unresolved knowledge gaps. After the agent builds, poc.py trace shows which assumptions made it into code with no human source ever cited.

The AI isn't grading its own exam. The spec is the answer key.

poc.py verify takes this further. After the agent builds, it parses the file's actual structure using Python's built-in ast module — extracting every function definition, conditional branch, and return path. It cross-checks each one against the seeded claims. Any structural unit with no resolved claim surfaces as a deterministic Knowledge Gap, regardless of how confident the model was when it wrote the code.

How to Install proof-of-contribution

Mac and Linux

mkdir -p ~/.claude/skills
git clone https://github.com/dannwaneri/proof-of-contribution.git \
  ~/.claude/skills/proof-of-contribution

Windows PowerShell

New-Item -ItemType Directory -Force -Path "$HOME\.claude\skills"
git clone https://github.com/dannwaneri/proof-of-contribution.git `
  "$HOME\.claude\skills\proof-of-contribution"

That's the entire installation. No package to install, no configuration file to edit. The skill is a markdown file the agent reads. The CLI is a Python script that runs locally.

Verify the Install:

ls ~/.claude/skills/proof-of-contribution/

You should see SKILL.md, poc.py, assets/, and references/. If the directory is empty, the clone failed — check your internet connection and try again.

How to Scaffold Your Project

The scaffold script creates the database, config, CLI, and GitHub integration in your project root. Run it once per project.

Mac and Linux

cd /path/to/your/project
python ~/.claude/skills/proof-of-contribution/assets/scripts/poc_init.py

Windows PowerShell

cd C:\path\to\your\project
python "$HOME\.claude\skills\proof-of-contribution\assets\scripts\poc_init.py"

You should see output like this:

🔗 Proof of Contribution — init

  →  Project root: /path/to/your/project
  ✔  Created .poc/config.json
  ✔  Created .poc/.gitignore  (db excluded from git, config tracked)
  ✔  Created .poc/provenance.db  (SQLite — no extra infra needed)
  ✔  Created .github/PULL_REQUEST_TEMPLATE.md
  ✔  Created .github/workflows/poc-check.yml
  ✔  Created poc.py  (local CLI — includes import-spec command)
  ✔  Created .gitignore

✔ Proof of Contribution initialised for 'your-project'

This creates four things in your project:

your-project/
├── .poc/
│   ├── config.json      ← project settings (commit this)
│   ├── provenance.db    ← SQLite database (local only, gitignored)
│   └── .gitignore
├── .github/
│   ├── PULL_REQUEST_TEMPLATE.md
│   └── workflows/
│       └── poc-check.yml
└── poc.py               ← your local CLI

• .poc/ — the tool's local data directory. config.json stores project settings and is committed to git. provenance.db is the SQLite database where attribution records and knowledge gaps are stored — local only, gitignored.

• poc.py — your local CLI, copied into the project root. Run python poc.py trace, python poc.py verify, and every other command directly without a global install.

• .github/PULL_REQUEST_TEMPLATE.md — a PR template with the ## 🤖 AI Provenance section pre-filled. Developers fill it in when submitting PRs that contain AI-generated code.

• .github/workflows/poc-check.yml — the optional GitHub Action for PR enforcement. Installed but dormant until you push the workflow file and enable it in your repo settings.

Windows note: if the scaffold fails with a UnicodeEncodeError, the emoji in the PR template is hitting a Windows encoding limit. Open assets/scripts/poc_init.py in a text editor and find every line ending with .write_text(...). Change each one to .write_text(..., encoding="utf-8"). Save and re-run.

Verify the Scaffold Worked

python poc.py report

Expected output:

Proof of Contribution Report
────────────────────────────────────────
  Artifacts tracked    : 0
  With provenance      : 0  (0%)
  Unresolved gaps      : 0
  Resolved claims      : 0
  Human experts        : 0

Empty database, clean state. You're ready.

How to Record Your First Provenance Entry

Before we dive in here, I just want to clear something up. Earlier, I described poc.py verify as detecting Knowledge Gaps automatically — and it does. But the static analyser can only tell you that a function has no human citation. It can't tell you which human source inspired it. That knowledge lives in your head, not in the code.

poc.py add is where you supply that context. After the agent builds a file, you record the human sources you actually drew on: the GitHub discussion you read before prompting, the Stack Overflow answer that shaped the approach. Those records become the attribution chain poc.py trace surfaces — and what closes the gaps poc.py verify flags.

verify finds the gaps. add fills them.

poc.py add records attribution for a file interactively. You can run it on any AI-generated file in your project.

python poc.py add src/utils/parser.py

You'll see a prompt:

Recording provenance for: src/utils/parser.py
(Press Ctrl+C to cancel)

  Human source URL (or Enter to finish):

Enter the URL of the human-authored source that inspired the code. This could be a GitHub discussion, a Stack Overflow answer, a documentation page, a blog post, or an RFC.

  Human source URL (or Enter to finish): https://github.com/TanStack/query/discussions/123
  Author handle: tannerlinsley
  Platform (github/stackoverflow/docs/other): github
  Source title: Cursor pagination discussion
  What specific insight came from this? cursor beats offset for live-updating datasets
  Confidence HIGH/MEDIUM/LOW [MEDIUM]: HIGH
  ✔ Recorded.

Add as many sources as apply. Press Enter on a blank URL when you're done.

  Human source URL (or Enter to finish): 
✔ Provenance saved. Run: python poc.py trace src/utils/parser.py

Check What You Recorded

python poc.py trace src/utils/parser.py

Provenance trace: src/utils/parser.py
────────────────────────────────────────────────────────────
  [HIGH]  @tannerlinsley on github
          Cursor pagination discussion
          https://github.com/TanStack/query/discussions/123
          Insight: cursor beats offset for live-updating datasets

No knowledge gaps — because you recorded a source. If the file had parts with no human source, they would appear below as gaps.

See All Experts in Your Graph

Every poc.py add call stores not just the URL but the author — their handle, platform, and the specific insight they contributed. Run it across enough files, and those authors accumulate into a knowledge graph: a local record of which human experts your codebase drew from, which files their knowledge shaped, and how many artifacts trace back to their work.

poc.py experts surfaces the top contributors. On a new project, it'll be one or two entries. On a mature codebase, it becomes a map of whose knowledge is load-bearing — the people you'd want to consult if that part of the code ever needed to change.

python poc.py experts

Top Human Experts in Knowledge Graph
──────────────────────────────────────────────────────
  @tannerlinsley            github          1 artifact(s)

How to Use import-spec to Seed Knowledge Gaps

This is the most important command in the tool. It connects proof-of-contribution with spec-writer and makes Knowledge Gaps deterministic.

When you use spec-writer before building a feature, it generates an ## Assumptions to review section — every implicit decision is impact-rated HIGH, MEDIUM, or LOW. The import-spec command reads that section and seeds those assumptions into the database as unresolved gaps before the agent writes a line of code.

After the agent builds, any assumption that made it into the implementation without a cited human source surfaces automatically in poc.py trace. You don't need to know which parts of the code are uncertain. The spec already told you.

Step 1 — Create a Test Spec

If you don't have a spec-writer output yet, create one manually to see how the import works.

Mac and Linux:

cat > test-spec.md << 'EOF'
## Assumptions to review

1. SQLite is sufficient for single-developer use — Impact: HIGH
   Correct this if: you need team-shared provenance

2. Filepath is the artifact identifier — Impact: MEDIUM
   Correct this if: you use content hashing instead

3. REST pattern for any future API — Impact: LOW
   Correct this if: you prefer GraphQL
EOF

Windows PowerShell:

python -c "
content = '''## Assumptions to review

1. SQLite is sufficient for single-developer use - Impact: HIGH
   Correct this if: you need team-shared provenance

2. Filepath is the artifact identifier - Impact: MEDIUM
   Correct this if: you use content hashing instead

3. REST pattern for any future API - Impact: LOW
   Correct this if: you prefer GraphQL'''
open('test-spec.md', 'w', encoding='utf-8').write(content)
print('test-spec.md created')
"

Windows note: don't use PowerShell's echo to create spec files. PowerShell saves files as UTF-16, which causes a UnicodeDecodeError when import-spec reads them. The python -c approach above writes UTF-8 correctly.

Step 2 — Import the Assumptions

python poc.py import-spec test-spec.md --artifact src/utils/parser.py

Spec assumptions imported — 3 Knowledge Gap(s) seeded
───────────────────────────────────────────────────────
  1. [HIGH] SQLite is sufficient for single-developer use
       Correct if: you need team-shared provenance
  2. [MEDIUM] Filepath is the artifact identifier
       Correct if: you use content hashing instead
  3. [LOW] REST pattern for any future API
       Correct if: you prefer GraphQL

  →  Bound to: src/utils/parser.py
  After the agent builds, run:
  python poc.py trace src/utils/parser.py
  python poc.py add src/utils/parser.py

Step 3 — Trace the Gaps

python poc.py trace src/utils/parser.py

Knowledge gaps (AI-synthesized, no human source):
  • REST pattern for any future API [Correct if: you prefer GraphQL]
  • SQLite is sufficient for single-developer use [Correct if: you need team-shared provenance]
  • Filepath is the artifact identifier [Correct if: you use content hashing instead]

  Resolve gaps: python poc.py add src/utils/parser.py

Three gaps, colour-coded by urgency. The HIGH-impact assumption — SQLite for single-developer use — appears in red. The LOW-impact one appears in green. When you run poc.py add and record a human source with an insight that overlaps the gap text, the gap auto-closes.

Preview Without Writing

python poc.py import-spec test-spec.md --dry-run

This parses the spec and prints what would be seeded without touching the database. This is useful before committing to an import.

Check the Overall Health

python poc.py report

Proof of Contribution Report
────────────────────────────────────────
  Artifacts tracked    : 1
  With provenance      : 0  (0%)
  Unresolved gaps      : 3
  Resolved claims      : 0
  Human experts        : 1
  ⚠ Less than 50% of artifacts have provenance records.
  ⚠ 3 unresolved Knowledge Gap(s).
    Run `poc.py trace <filepath>` to locate them.

How to Trace Human Attribution

poc.py trace is the command you'll use most. It shows the full human attribution chain for any file and lists any knowledge gaps — parts of the code with no traceable human source.

python poc.py trace src/utils/parser.py

A file with both attribution and gaps looks like this:

Provenance trace: src/utils/parser.py
────────────────────────────────────────────────────────────
  [HIGH]  @juliandeangelis on github
          Spec Driven Development methodology
          https://github.com/dannwaneri/spec-writer
          Insight: separate functional from technical spec

  [MEDIUM] @tannerlinsley on github
           Cursor pagination discussion
           https://github.com/TanStack/query/discussions/123
           Insight: cursor beats offset for live-updating datasets

Knowledge gaps (AI-synthesized, no human source):
  • Error retry strategy — no human source cited
  • CSV column ordering — AI chose this arbitrarily

  Resolve gaps: python poc.py add src/utils/parser.py

The human attribution section shows every cited source, colour-coded by confidence. The knowledge gaps section shows every assumption that shipped without a human citation — either seeded from a spec via import-spec, or flagged by Claude in the Provenance Block.

Resolving Gaps

Run poc.py add on any file with open gaps:

python poc.py add src/utils/parser.py

When you enter an insight that shares words with an open gap claim, the gap auto-closes. Run poc.py trace again to confirm it's resolved.

How to Verify with Static Analysis

poc.py verify is the command that closes the epistemic trust gap completely. It detects Knowledge Gaps by analysing the file's actual code structure — not by asking the AI what it doesn't know.

Run it after the agent builds, once you've seeded gaps with import-spec:

python poc.py verify src/utils/parser.py

Expected output:

Verify: src/utils/parser.py
────────────────────────────────────────────────────────────
  Structural units detected : 11
  Seeded claims             : 3
  Covered by cited source   : 2
  Deterministic gaps        : 1

Deterministic Knowledge Gaps (no human source):
  • function: handle_concurrent_writes (lines 47–61)
      Seeded assumption: concurrent write handling — AI chose this arbitrarily

  Resolve: python poc.py add src/utils/parser.py

The gap shown is not something Claude admitted. It's something the analyser found by comparing the file's function list against your seeded claims. The function handle_concurrent_writes exists in the code but has no resolved human citation in the database. That's the gap.

What the Exit Codes Mean

python poc.py verify src/utils/parser.py
echo $?   # Mac/Linux

python poc.py verify src/utils/parser.py
echo $LASTEXITCODE   # Windows PowerShell

• Exit code 0 — no gaps, all detected units have cited sources

• Exit code 1 — gaps found, resolve with poc.py add

• Exit code 2 — file not found or unsupported language

Exit code 1 integrates directly into CI pipelines. Add poc.py verify to your GitHub Action or pre-commit hook and gaps block the build before they reach production.

Run it Without a Seeded Spec

If you haven't run import-spec first, verify still works — it falls back to structural analysis and surfaces every uncited function and branch as a gap:

python poc.py verify src/utils/parser.py

⚠ No spec imported — showing all uncited structural units.
  Run: python poc.py import-spec spec.md --artifact src/utils/parser.py
  for deterministic gap detection.

Deterministic Knowledge Gaps (no human source):
  • function: parse_query (lines 1–7)
  • branch: if not text (lines 2–3)
  • function: fetch_results (lines 9–12)
  ...

It's less precise than the spec-writer path — every structural unit shows rather than only the ones tied to named assumptions — but it's useful as a baseline on any file, new or old.

The --strict Flag

python poc.py verify src/utils/parser.py --strict

Strict mode flags every uncited structural unit as a gap even when claims are seeded. You can use it when you want zero tolerance: any function or branch without a resolved human source fails the check.

How to Enable PR Enforcement

Once poc.py trace has saved you real hours — not before — enable the GitHub Action. The distinction matters. Turning it on day one frames the tool as overhead. Turning it on after the team already finds value frames it as a standard.

git add .github/ .poc/config.json poc.py
git commit -m "chore: add proof-of-contribution"
git push

After that, every PR is checked for an ## 🤖 AI Provenance section. The scaffold already created the PR template with that section included. Developers fill it in naturally once they're already running poc.py trace locally — the template just asks them to record what they already know.

Developers who write fully human code opt out by adding 100% human-written anywhere in the PR body. The action skips the check automatically.

What the Action Checks

The action reads the PR description and looks for:

1. The ## 🤖 AI Provenance heading

2. At least one populated row in the attribution table

If the section is missing or the table is empty, the action fails and posts a comment explaining what to add. The comment includes a link to poc.py trace <filepath> so the developer knows exactly where to look.

Where to Go Next

Use it with spec-writer on a Real Feature

The real value of import-spec is on actual features, not test specs. If you use spec-writer, the workflow is:

/spec-writer "your feature description"

Save the output to spec.md. Then:

python poc.py import-spec spec.md --artifact src/path/to/output.py

Build the feature with your agent. Then run poc.py trace to see which assumptions made it into code with no human source. Resolve the HIGH-impact gaps first — those are the ones that will cause production incidents.

Activate the Claude Code Skill

The SKILL.md file makes Claude automatically append a Provenance Block to every generated artifact when the skill is active. The block lists human sources Claude drew from and flags what it synthesized without any traceable source.

To activate it in Claude Code, the skill is already installed at ~/.claude/skills/proof-of-contribution/. Claude Code loads it automatically when you are in a project that has .poc/config.json.

A generated Provenance Block looks like this:

## PROOF OF CONTRIBUTION
Generated artifact: fetch_github_discussions()
Confidence: MEDIUM

## HUMAN SOURCES THAT INSPIRED THIS

[1] GitHub GraphQL API Documentation Team
    Source type: Official Docs
    URL: docs.github.com/en/graphql
    Contribution: cursor-based pagination pattern

[2] GitHub Community (multiple contributors)
    Source type: GitHub Discussions
    URL: github.com/community/community
    Contribution: "ghost" fallback for deleted accounts
                  surfaced in bug reports

## KNOWLEDGE GAPS (AI synthesized, no human cited)
- Error handling / retry logic
- Rate limit strategy

## RECOMMENDED HUMAN EXPERTS TO CONSULT
- github.com/octokit community for pagination

The Knowledge Gaps section is the part no other tool produces. It's where AI admits what it synthesized without a traceable human source — before that gap becomes a production incident.

Upgrade When You Outgrow SQLite

The default database is SQLite — local only, no infra required. When you need team sharing or graph queries, the references/ directory in the repo has migration guides:

Manual Tracking vs. proof-of-contribution

The tool doesn't replace code review. It gives code review the context it needs to catch the right things.

The archaeology scenario — two days tracing a bug through dead-end commit messages — takes thirty seconds with poc.py trace. The code still has gaps, and it always will. But now you know where they are.

Built by Daniel Nwaneri. The spec-writer skill that feeds import-spec is at github.com/dannwaneri/spec-writer. The full proof-of-contribution repo is at github.com/dannwaneri/proof-of-contribution.

Agent skills fix this. A skill is a markdown file that loads into Claude Code's context automatically when you need it. You write the workflow once. The agent follows it every time. And because skills follow an open standard, the same file works in Claude Code, GitHub Copilot, Cursor, and Gemini CLI.

This tutorial shows you how to build a skill from scratch. You will build a commit-message-writer — a skill that reads your staged changes and generates a structured commit message following the Conventional Commits standard. By the end, you will have a working skill installed and ready to use, and you will understand the structure well enough to build any skill you need.

Table of Contents

1. What an Agent Skill Is

2. How to Choose What to Build

3. How to Structure Your Skill

4. How to Write the Description

5. How to Write the Instructions

6. How to Build the commit-message-writer Skill

7. How to Install and Test Your Skill

8. How to Improve Your Skill Over Time

9. Where to Go Next

What an Agent Skill Is

A skill is a folder containing a SKILL.md file. That file has two parts: a YAML frontmatter block at the top, and a markdown body below it.

my-skill/
└── SKILL.md

The frontmatter tells the agent what the skill is called and when to use it. The body tells the agent what to do when it loads the skill. Here is the minimal structure:

---
name: my-skill
description: What this skill does and when to use it.
---
 
# My Skill
 
Instructions for the agent go here.

When you invoke a skill — either explicitly with /skill-name or by describing what you want — the agent reads the SKILL.md body and follows the instructions inside it. The frontmatter never reaches the agent's instructions. It's metadata the skill system uses to decide whether to load the skill at all.

How the Agent Decides to Load a Skill

This is the most important thing to understand before you write your first skill: the agent decides whether to load your skill based entirely on the description field.

Skills appear in Claude Code's context as a list of names and descriptions. When you make a request, the agent scans that list and loads any skill whose description matches what you're asking for. If the description is vague, the skill won't load when you need it. If the description is too narrow, it won't load for variations of the same request.

The instructions in the body only matter after the skill loads. Getting the description right is what determines whether the skill loads at all.

What Skills Are Not

Skills are instruction files. They cannot run code on their own — but they can instruct the agent to run code using its existing tools. They are not plugins, extensions, or packages. They have no runtime. They are markdown files the agent reads, like a recipe a chef follows.

How to Choose What to Build

The best skills share three properties.

1. They encode a repeatable workflow. If you do something differently every time, a skill won't help. If you follow the same steps every session — even if you explain them differently each time — that's a skill candidate.

2. They have a clear trigger. You should be able to finish the sentence "I need this skill when I want to...". If you can't finish that sentence in one clause, the workflow isn't scoped enough for a skill.

3. They produce a consistent output format. Skills that output in a fixed structure — a commit message, a code review, a spec — are easier to build and test than skills that produce open-ended prose.

Good candidates: commit messages, pull request descriptions, code reviews, changelog entries. Bad candidates: "help me think through this", "make this better" — too open-ended to encode in a skill.

For this tutorial, commit message generation is the right scope. The trigger is obvious (you want to commit), the workflow is defined (read staged changes, apply Conventional Commits format), and the output is structured (a commit message with a specific shape).

How to Structure Your Skill

Every skill starts as a single folder with a single file:

commit-message-writer/
└── SKILL.md

As skills grow, they can include additional files the agent loads as needed:

commit-message-writer/
├── SKILL.md          ← always loaded when skill triggers
└── references/
    └── examples.md   ← loaded only when the agent needs examples

The SKILL.md body should stay under 500 lines. If your instructions are growing beyond that, move supporting detail into a references/ subfolder and tell the agent when to read those files. This keeps the skill lean — the agent only loads what it needs.

For this tutorial, a single SKILL.md is enough.

How to Write the Description

The description field is the trigger condition. It determines when your skill loads and when it doesn't. Most skills fail not because the instructions are wrong, but because the description doesn't match how people actually ask for help.

Here is a weak description:

description: Generates commit messages.

This will undertrigger. "Generate a commit message" will load it. "Write a commit for my changes" probably won't. "Summarize my staged diff" definitely won't — even though all three are asking for the same thing.

Here is a stronger description:

description: Generates structured commit messages following the Conventional Commits standard. Use when you want to commit your changes and need a well-formatted message. Triggers on "write a commit message", "commit my changes", "summarize my staged diff", "what should my commit say", or any request to describe or document code changes for version control.

The pattern is: what the skill does + when to use it + specific trigger phrases. The trigger phrases cover the different ways a developer might ask for the same thing.

Two rules for descriptions:

Be specific about the output. "Generates commit messages" is vague. "Generates structured commit messages following the Conventional Commits standard" tells the agent and the user exactly what they'll get.

Be slightly pushy. The agent has a natural tendency to undertrigger skills — to handle requests itself rather than loading a skill. A description that explicitly lists trigger phrases counteracts this. You are not being redundant. You are training the trigger.

How to Write the Instructions

The body of SKILL.md is where you define what the agent does when the skill loads. Good instructions follow two principles.

Generate first, clarify second. The agent should produce output immediately rather than asking clarifying questions. If it needs to make assumptions, it should make them and flag them — not ask. Asking questions before producing output adds friction and loses the benefit of having a skill at all.

Define the output format explicitly. Don't say "write a good commit message." Say exactly what the structure is, what fields are required, what the character limits are. The more specific the output format, the more consistent the results.

Here is what weak instructions look like:

# Commit Message Writer
 
Look at the staged changes and write a commit message that describes what changed.

That will produce different results every time — different formats, different lengths, different conventions. It's not a skill. It's a prompt.

Here is what strong instructions look like:

# Commit Message Writer
 
Read the staged diff using `git diff --staged`. Generate a commit message
following the Conventional Commits standard.
 
Output format:
type(scope): short description under 72 characters
 
Body (if changes are non-trivial):
- What changed and why, not how
- One bullet per logical change
 
Footer (if applicable):
BREAKING CHANGE: description
Closes #issue-number

The agent knows exactly what to produce. The output will be consistent across sessions, across projects, and across agents that support the standard.

How to Build the commit-message-writer Skill

Now build it. Create the skill directory:

mkdir -p ~/.claude/skills/commit-message-writer

On Windows PowerShell:

Note: PowerShell uses backtick (`) for line continuation, not backslash.

New-Item -ItemType Directory -Force -Path "$HOME\.claude\skills\commit-message-writer"

Create the SKILL.md file inside that directory. Here is the complete content:

---
name: commit-message-writer
description: Generates structured commit messages following the Conventional Commits
  standard. Use when you want to commit your changes and need a well-formatted message.
  Triggers on "write a commit message", "commit my changes", "summarize my staged
  diff", "what should my commit say", or any request to describe or document staged
  changes for version control.
---
 
# commit-message-writer
 
You generate structured commit messages from staged git changes.
 
## How to invoke
 
Run `git diff --staged` to read the staged changes. If nothing is staged, tell the
user and suggest they run `git add` first.
 
Generate first. Do not ask clarifying questions before producing the commit message.
If you need to make assumptions about scope or type, make them and note them after
the output.
 
## Output format
 
~~~
type(scope): short description
 
[body — optional, include if changes are non-trivial]
 
[footer — optional]
~~~
 
**Type** — choose one:
- `feat` — a new feature
- `fix` — a bug fix
- `docs` — documentation changes only
- `refactor` — code change that neither fixes a bug nor adds a feature
- `test` — adding or updating tests
- `chore` — build process, tooling, or dependency updates
 
**Scope** — the module, file, or area affected. Use the directory name or component
name. Omit if the change spans the entire codebase.
 
**Short description** — imperative mood, under 72 characters, no period at the end.
"Add user authentication" not "Added user authentication" or "Adds user authentication."
 
**Body** — what changed and why, not how. One bullet per logical change. Skip if the
short description is self-explanatory.
 
**Footer** — include `BREAKING CHANGE:` if the commit breaks backward compatibility.
Include `Closes #N` if it resolves a GitHub issue.
 
## Quality rules
 
- Never use "updated", "changed", or "modified" in the short description — be specific
- Never write "various improvements" or "misc fixes" — name what improved
- If more than three files changed across unrelated concerns, flag it:
  "These changes may be better split into separate commits: [list concerns]"
- The short description must be under 72 characters — count before outputting
 
## Example output
 
Input: staged changes adding a rate limiter to an API endpoint
 
~~~
feat(api): add rate limiting to /query endpoint
 
- Limits requests to 100 per minute per IP using Cloudflare's rate limit binding
- Returns 429 with Retry-After header when limit is exceeded
- Adds rate limit configuration to wrangler.toml
 
Closes #47
~~~

Save that file. The skill is built.

How to Install and Test Your Skill

Verify the File Exists

cat ~/.claude/skills/commit-message-writer/SKILL.md

You should see the full SKILL.md content. If you get an error, check the directory path.

Test the Skill

Open Claude Code in any git repository that has staged changes. Type:

/commit-message-writer

The agent will read your staged diff and produce a commit message following the format you defined.

You can also trigger it naturally:

write a commit message for my staged changes

what should my commit say

summarize my diff for git

All three should load the skill and produce a structured commit message. If the skill doesn't trigger on natural language requests, the description needs more trigger phrases — see the improvement section below.

Test Edge Cases

Test these cases before relying on the skill in production:

# Stage nothing, then ask for a commit message
git add -p  # stage nothing
# In Claude Code: "write a commit message"
# Expected: skill tells you nothing is staged and suggests git add

# Stage changes across unrelated files
git add src/api.ts src/styles.css README.md
# In Claude Code: "write a commit message"  
# Expected: skill flags that commits may be better split

How to Improve Your Skill Over Time

The first version of any skill is a draft. You improve it by observing where it produces inconsistent or wrong output, then updating the instructions.

When the Skill Undertriggers

If you type "summarize my changes for git" and the skill doesn't load, add that phrase to the description's trigger list:

description: ... Triggers on "write a commit message", "commit my changes",
  "summarize my staged diff", "summarize my changes for git", ...

The description is your primary lever for fixing triggering problems.

When the Output Format Drifts

If the agent starts producing commit messages that don't match your format — wrong type, missing scope, body in the wrong style — the instructions need to be more explicit. Add a concrete example that shows the failure and the correct output:

## Common mistakes to avoid
 
Wrong: "Updated the authentication flow"
Right: "refactor(auth): simplify token validation logic"
 
Wrong: "Fixed bugs"
Right: "fix(api): handle null response from upstream service"

Concrete counterexamples are more effective than abstract rules.

When the Scope Grows

If you find yourself wanting the skill to handle related tasks — reviewing commit messages, generating changelogs, writing PR descriptions — resist the urge to add everything to one skill. Build separate skills. Each skill should do one thing well. The Agent Skills standard is designed for composition, not for monolithic instructions.

Where to Go Next

The commit-message-writer covers the core pattern. The same structure works for any repeatable workflow.

Pull request descriptions follow the same shape — read the diff, apply a structure, produce consistent output. The trigger phrases are different ("write a PR description", "summarize my branch for review") and the output format adds sections for motivation and testing, but the SKILL.md structure is identical.

Code review checklists work well as skills when your team has a standard review process. The trigger is "review this code" or "check this PR", and the instructions encode whatever your team actually checks — security concerns, test coverage, naming conventions.

The commit-message-writer is the simplest skill architecture — instructions only. As your skills grow more specialized, two other patterns become useful.

The first adds a references/ directory: the voice-humanizer skill loads a CORPUS.md file containing the author's published writing, which the agent reads when it needs to check output against a specific style. The second adds quality rules and structured output formats that make results stricter and more consistent — that's the pattern spec-writer uses to surface assumptions inline. Each is the same SKILL.md structure at a different level of complexity.

Start with instructions only. Add references when the agent needs external context. Add output format rules when consistency matters more than flexibility.

The Agent Skills standard is supported in Claude Code, GitHub Copilot in VS Code, Cursor, and Gemini CLI. A skill you build once installs across all of them. The install path differs by agent:

The SKILL.md format is the same across all of them.

The commit-message-writer you just built is a working skill. The next one will take less time. By the third, you will start seeing workflows you repeat and immediately think: that should be a skill.

That's the point.

To make things even worse, how about a CORS error that completely prevented you from showing the page?

It happens, right? Going back to the backend team and getting a quick fix for these issues would be ideal, but may not be realistic in most cases. It depends on the availability of the backend developers, the priority items they're working on, communication protocols between teams, and even interpersonal relationships.

Now, the question is, can you afford to wait? Wait for things to work in your favour within the given deadline so that you can show that demo or deliver the work to your customer? The answer is NO. You may not have that luxury.

Today, in this article, you'll learn a couple of mind-blowing tips and tricks that will save you from these situations. You'll understand how to set up your Chrome browser so that you can continue with your frontend development even when the backend API returns an incorrect response or a CORS error.

This is a step-by-step guide that'll help make you comfortable with all the required configurations and get you set up to use it on your web projects. This guide is also available as a video tutorial as part of the Thinking in Debugging series. You can check it out if you’d like:

Let's get started with the problems and their solutions.

Table of Contents

1. Problem 1: The Backend Response Is Wrong

2. Problem 2: Validating a UI Scenario Without Backend Changes

3. Problem 3: Handling CORS Errors

4. Additional Tips

   • Applying Overrides Globally

   • Disabling or Removing Overrides

5. Learn More From the Thinking in Debugging Mindset

6. Before We End…

Problem 1: The Backend Response Is Wrong

Here is a classic case of a wrong API response, but you still need to continue with your frontend work.

Take a look at the image below. Do you see that something is off? Yeah, on the first card, the spelling of Banana seems to be misspelled as Banananana. This user interface is constructed using the data we have received as an API response.

We can go to the backend team and request that they fix it as soon as possible. But it may not happen until the next sprint starts, which might be 15 days from now.

So, what can we do to continue with our work and all the validations on the frontend side? We can use the Content Overriding feature of the Chrome browser to mitigate this situation.

How to Use Content Overriding

First, open up the DevTools of your Chrome browser by pressing the F12 (on Mac, Cmd+F12) key. Then move to the network tab and inspect the API request that returns the incorrect response.

Next, right-click on the API request and select the Override content option from the context menu.

You may wonder what content means here, and what I am overriding? You're overriding the API response so that it can reflect on the UI locally.

This will bring up a UI at the top where you can select a folder to store override files. It's important to understand that all the content overrides are locally stored on your machine's hard disk. This means you can use these persisted overrides again and again until someone fixes the issue permanently at the backend.

Now click on the Select folder button.

This will open up the folder explorer for you. Create a new folder and select it, or select an existing folder where you want to save the overrides. In my case, I've named the folder as debug_devtools.

Now, Chrome DevTools will ask for confirmation that you're allowing DevTools to edit files on your local system. Just click on the Allow button.

That's all for the setup. Now, you'll find the same response in the editable mode under the Sources tab of DevTools. Let's take a deeper look at the image below:

1. The Local overrides are listed under the Sources > Oveerides tab of the DevTools.

2. On the left side, the Enable Local Overrides checkbox is selected, and the overrides are listed below. You can find the same folder you created before, and under that, you'll see another folder called localhost:3001 and a file called edibles under it. The localhost:3001 folder name is related to the API endpoint namespace we're connecting to. The edibles file name under it goes with the request name.

3. On the right side, you can see the content (that is, the response to the edibles request) in editable mode.

You can even cross-check now by traversing to the file system's debug_devtools folder. You should find the same folders and files as you saw in the DevTools.

You can open up the edibles file. The file content should match exactly the response you saw before.

Now, it's time to override. Coming to the Sources tab's editable response panel, you can fix the spelling. Save your changes using Ctrl + S (or Cmd + S).

Now, hard refresh your browser. You should be able to see your change reflected on the UI.

Awesome!! You can now share this overridden response (the edibles file) with other developers to point to from their Chrome DevTools to get the same local fix until the backend fixes it.

Problem 2: Validating a UI Scenario Without Backend Changes

Imagine you need to validate that certain items are low in stock on an item listing page. If the stock quantity of an item hits 50 or below, you want to show a Low Stock label for that item.

Now, what if the API response doesn't return a quantity of 50 or below? Content overriding can come to the rescue once again!

You can edit the response to set the quantity value to 50 or below and follow the same process as before to reflect the change on the UI. Look at the image below:

1. We have edited the quantity on the right-side panel.

2. Once saved and refreshed, we not only see the updated count on the UI, but it also runs the underlying JavaScript logic to show the Low Stock label automatically. This is a superpower.

Problem 3: Handling CORS Errors

Cross-Origin Resource Sharing (CORS) is a browser security feature that allows a web server to explicitly grant requests coming from a domain other than its own. By default, browsers don't allow these cross-origin requests and follow a strict rule called Same Origin Resource Sharing.

In many cases, your API server and the web server could be hosted on different domains. In those cases, when the web application attempts to access an API, it faces the CORS error.

On the server side, you need to have explicit configurations to allow cross-origin requests. For example, you need to add the following response headers:

Access-Control-Allow-Origin: http://localhost:5174
Access-Control-Allow-Methods: GET
Access-Control-Allow-Headers: *

So, again, it may not be guaranteed that your CORS error will be resolved at the server side as soon as you want. But you cann't afford to get blocked due to it. So, what's the way around? Yes! The overriding, but this time, overriding the response header.

Go to the network tab of the Chrome DevTools and right-click on the request that has the CORS error. Now, select the Override headers option from the context menu.

By the way, have you noticed that the Override content option is disabled here? This is because we don't have any response as content from this request, as it got an error.

Clicking on the Overriding headers will take you to the Headers tab where you can find the option to add additional headers to the response headers. Click on the + Add header button to add the CORS-related headers.

Add all three headers with their respective values one by one:

Access-Control-Allow-Origin: http://localhost:5174 
Access-Control-Allow-Methods: GET 
Access-Control-Allow-Headers: *

Each of these headers has its own important use:

1. With the Access-Control-Allow-Origin header, you can specify the origin domains that are allowed to have a cross-origin request to the server. In this case, the value is http://localhost:5174 where we're running a Vite-based ReactJS app.

2. The header Access-Control-Allow-Methods specifies what kind of HTTP methods are allowed from the originating domain. In this case, we're allowing only the GET method.

3. The Access-Control-Allow-Headers HTTP response headers specify which HTTP headers can be safely used during a cross-origin request.

Alright, let's add them all and save.

Like overriding content, overriding the header will also create a folder with the context of the server domain, and under that, a file called .headers. As the file name starts with a dot(.), it may be treated as a hidden file by most operating systems. So make sure you go through the OS settings to view the hidden files to view this file.

Once you view and open the file, you'll see the headers you have added with overriding.

Now, hard refresh your browser, and try to perform the same operation that was giving you the CORS error before. Wow, the error has gone now! You should be able to see the request success and the response coming back from the server.

Just imagine, not a single line of server-side code changes, and you're unblocked so you can move forward with your client-side UI work. Fantastic, isn't it?

Additional Tips

Before we end, let's learn about a couple more handy tips.

Applying Overrides Globally

We applied the CORS error-related header overriding only on the /user API endpoint. What if you need to apply the same overriding for other endpoints, too? You can do it easily by following these simple steps:

1. Navigate to the Sources tab.

2. Select the Overrides sub-tab.

3. Click on the .headers override.

4. On the right-side panel, change the value of the Apply to to *.

That's it. Now, the same response headers will be applied as overrides for all the endpoints.

Disabling or Removing Overrides

Sometimes, you might want to disable or remove overrides. To disable overrides without removing them, just uncheck the Enable Local Overrides checkbox. To remove all the overrides permanently, click on the stop icon at the top-right corner. Also, to selectively remove an override, right-click on it and delete.

Learn More From the Thinking in Debugging Mindset

If you've liked this practical, example-driven guide, you'll enjoy my other debugging-related content from the Thinking in Debugging series. Please check it out.

Before We End…

That’s all! I hope you found this insightful.

Let’s connect:

• Subscribe to my YouTube Channel.

• Check out my courses, 40 Days of JavaScript and 15 Days of React Design Patterns

• Follow on LinkedIn if you don't want to miss the daily dose of up-skilling tips.

• Join my Discord Server, and let’s learn together.

• Follow my work on GitHub.

See you soon with my next article. Until then, please take care of yourself and keep learning.

The tool is spec-writer: a Claude Code skill that takes a vague feature request and generates a structured spec, technical plan, and task breakdown before a single line of code gets written.

The problem it solves is one most developers hit within their first week of using AI coding agents seriously: the agent writes confidently in the wrong direction and you pay for it twice, once in tokens, once in rewrites.

This tutorial shows you how to install spec-writer, how to invoke it on a real feature, and how to read the output so you can catch the assumptions that would have wasted your time.

Table of Contents

1. The Problem with Prompting Agents Directly

2. What Spec-Driven Development Is

3. How spec-writer Works

4. How to Install spec-writer

5. How to Write Your First Spec

6. How to Read the Output

7. How to Hand the Spec to Your Agent

8. Where to Go Next

The Problem with Prompting Agents Directly

Here is what happens when you skip the spec.

You have a feature in your head: "Add a way for users to export their data." You open Claude Code and describe it. The agent produces code. It looks right. You run it. It's mostly right – except it exports everything including soft-deleted records, it doesn't paginate, it times out on large accounts, and it has no authentication check on the export endpoint.

None of those things were in your prompt. The agent guessed, and it guessed plausibly – which is worse than guessing obviously wrong. You didn't notice until testing.

This is the fundamental problem with prompting agents directly on anything non-trivial: your prompt carries your conscious requirements, but every feature has a shadow of requirements you didn't think to state. And the agent fills that shadow with assumptions.

Most of the time, those assumptions are reasonable. Some of the time, they're wrong in ways that take hours to unravel.

The failure mode isn't hallucination. It's the agent being exactly as helpful as the prompt allowed, which wasn't helpful enough.

Spec-Driven Development addresses this directly. The methodology – documented extensively by practitioners like Julián Deangelis – argues that a written spec isn't documentation overhead. It's the mechanism that forces you to make decisions before the agent does.

What Spec-Driven Development Is

Spec-Driven Development is the practice of writing a structured specification before you write code or prompt an agent. The spec defines what the feature must do, what assumptions are being made, and what tasks the implementation breaks into.

The key insight is what a spec is for. A spec is not trying to replace code. It's trying to surface the decisions that would otherwise be invisible. The agent will make those decisions either way: with a spec, you make them first. Without a spec, you discover them during testing.

The strongest counterargument to SDD comes from Gabriella Gonzalez: a sufficiently detailed spec is just code. She's right that some specs devolve into pseudocode so specific they might as well be implementations.

But that's a spec written at the wrong level of abstraction. The goal is to name the decisions, not to pre-implement them. "Only authenticated users can trigger this export" is a decision. "Call verifyJWT(token) and return 401 if it fails" is implementation. The spec needs the first. The agent handles the second.

SDD has three levels:

1. Spec-First: write a spec before every feature and hand it to the agent as context. This is the entry point and the workflow this tutorial focuses on.

2. Spec-Anchored: the spec lives in the repository and evolves alongside the code. When requirements change, you update the spec and re-prompt the agent to realign.

3. Spec-as-Source: the spec is the primary artifact. Code is generated from it and considered disposable. This is the most ambitious level and the direction many teams are moving toward.

spec-writer gets you to Spec-First immediately, with no ceremony.

How spec-writer Works

spec-writer is a Claude Code skill – a markdown file that loads into the agent's context and changes how it responds when invoked.

The skill follows one rule: generate first, flag assumptions inline. Instead of asking you clarifying questions before producing output, it generates the full spec immediately and marks every decision it made without your explicit input using [ASSUMPTION: ...] tags. Then you correct what's wrong.

This is faster than Q&A because it makes the decisions visible in a form you can react to rather than anticipate.

The output has three sections in fixed order:

1. SPEC: the what. One-line purpose, user stories, requirements, edge cases, and acceptance criteria in Given/When/Then format.

2. PLAN: the how. Stack and architecture decisions, data model changes, API contracts, testing strategy, and security constraints.

3. TASKS: the breakdown. Ordered, self-contained tasks each completable in a single agent session, each with its own acceptance criteria.

After the three sections, the skill produces an Assumptions summary: every [ASSUMPTION: ...] from the output, ranked by impact. This is the part you review before handing anything to the agent.

The skill is compatible with GitHub Spec Kit and OpenSpec. If you use either framework, save the spec output to your .specify/ or openspec/changes/ directory and continue from there.

How to Install spec-writer

spec-writer uses the Agent Skills standard, which means the same SKILL.md file works across Claude Code, Cursor, GitHub Copilot, Gemini CLI, and any other agent that supports the standard. You install it once and it works everywhere.

Installation

Create the skills directory if it doesn't exist and clone the repo:

mkdir -p ~/.claude/skills
git clone https://github.com/dannwaneri/spec-writer.git ~/.claude/skills/spec-writer

On Windows PowerShell:

(Note: PowerShell uses backtick (`) for line continuation, not backslash.)

New-Item -ItemType Directory -Force -Path "$HOME\.claude\skills"
git clone https://github.com/dannwaneri/spec-writer.git "$HOME\.claude\skills\spec-writer"

That's the entire installation. No package to install, no configuration file to edit, no API key. The skill is a markdown file. The agent reads it.

Verification

Open Claude Code and type:

/spec-writer test

If the skill is installed correctly, the agent will read the SKILL.md and produce a spec structure – even for "test" as input. You'll see the three sections and the Assumptions summary. If nothing happens, confirm that the ~/.claude/skills/spec-writer/SKILL.md file exists.

How to Write Your First Spec

The invocation pattern is:

/spec-writer [your feature description]

The description can be as rough as you'd write in a Slack message. The skill's job is to structure it. You don't need to be precise. Being precise is what the spec is for.

A Real Example

Here is a real invocation from the Foundation project, a federated knowledge base built on Cloudflare Workers:

/spec-writer Add CLI capture for Claude Code sessions stored in ~/.claude/projects/

That's twelve words. No mention of the tech stack, no data model details, no authentication requirements, no error handling spec. All of that comes out in the spec.

Here is the abbreviated output:

SPEC

One-line purpose: Developers can capture Claude Code session logs from their local filesystem into Foundation before they are deleted after 30 days.

Users and use cases:

• As a developer using Claude Code daily, I want my coding sessions captured automatically so that architectural decisions and debugging patterns don't disappear after 30 days.

• As a Foundation user, I want CLI sessions and browser extension captures in the same knowledge base so that I have one place to query across all my AI interactions.

Acceptance criteria:

Given a developer with Claude Code sessions in ~/.claude/projects/
When they run the Foundation CLI capture command
Then a list of uncaptured sessions is displayed, sorted by most recent first
 
Given a session already in Foundation
When the developer runs capture again
Then that session does not appear in the review list
 
Given a malformed .jsonl file
When the capture command processes it
Then an error is logged for that file and processing continues on remaining sessions

PLAN

Stack and architecture:

CLI capture runs locally — it needs to read the local filesystem, which
Cloudflare Workers cannot do. [ASSUMPTION: CLI capture is a local Node.js
or Bun script that calls the Foundation API to insert sessions, rather
than a Worker itself]

API contracts:

• POST /api/sessions/import – accepts parsed session JSON, returns session ID

• Returns 409 if session already exists

• Triggers evaluator pipeline after successful insert

TASKS

## Task 1: .jsonl parser
 
**What to build:** A parser that reads a Claude Code .jsonl session file
and outputs Foundation's internal message format.
**Files likely affected:** cli/src/parsers/claudeCode.js (create)
**Acceptance criteria:**
1. Parses a valid .jsonl file into the correct message format
2. Handles malformed lines without crashing — logs and skips
3. Returns empty array for empty file
**Dependencies:** none

Assumptions to review:

1. CLI capture is a local script calling the Foundation API, not a Worker
   Impact: HIGH
   Correct this if: you want a purely serverless approach
 
2. Manual curation before capture, not automatic bulk import
   Impact: HIGH
   Correct this if: you want automatic background capture
 
3. Session ID from .jsonl filename is the deduplication key
   Impact: MEDIUM
   Correct this if: session IDs are stored differently in your schema
 
4. No sensitive data scrubbing in v1
   Impact: MEDIUM
   Correct this if: your sessions contain credentials or keys

Twelve words in, four decisions surfaced immediately – three of which had real architectural implications.

The third assumption ("Session ID from .jsonl filename is the deduplication key") is the one that would have caused the most subtle bug. The agent would have implemented deduplication based on the filename and it would have worked until a session was renamed. The spec caught it before a line of code was written.

How to Read the Output

The output is designed to be scanned for [ASSUMPTION: ...] tags first, read for the tasks second.

Reading the Assumptions

Every [ASSUMPTION: ...] tag marks a place where the agent filled in something you didn't specify. Your job is to go through the Assumptions summary and decide for each one:

• Correct: the assumption is right, leave it

• Override: the assumption is wrong, restate it and re-run the spec

• Defer: the assumption doesn't matter for this iteration, mark it and move on

The impact rating tells you which assumptions to fix before you start coding. HIGH-impact assumptions affect architecture or data model. If they're wrong, fixing them requires rework. LOW-impact assumptions affect behavior details that are easy to change later.

Reading the Acceptance Criteria

The acceptance criteria in Given/When/Then format are the most useful part of the spec for catching scope errors. Read each one and ask: is this actually what I want?

Criteria are binary by design. "Returns 401 when unauthenticated" is a criterion. "Works correctly" is not. If you find yourself reading a criterion and thinking "well, it depends", then that's a signal that the criterion is hiding an assumption. Restate it.

Reading the Tasks

The tasks are ordered and self-contained. Each task produces a verifiable change. Before you hand any task to an agent, check two things:

1. Does the task have all the context it needs? If a task says "follow the existing auth pattern" and you haven't pointed the agent at your auth code, it will guess.

2. Does the acceptance criteria match what you'd actually test? If the criteria are vague, tighten them before the agent sees the task.

How to Hand the Spec to Your Agent

The spec is context, not a prompt. When you start an agent session for a task, include the relevant spec sections alongside the task description.

For Task 1 from the example above, your agent session might open like this:

Context:
- This is a federated knowledge base built on Cloudflare Workers, D1, and Vectorize
- Sessions are stored in ~/.claude/projects/ as .jsonl files
- The API runs at https://<your-worker>.workers.dev
 
Spec:
[paste the SPEC and PLAN sections]
 
Task:
[paste Task 1]

The context block is just an example. Replace it with your own project's tech stack, file locations, and API URL. The point is to give the agent the same context a new team member would need on day one.

The agent now has requirements, architecture context, and a single scoped task with binary acceptance criteria. It cannot guess the deduplication key incorrectly because the spec already resolved that assumption. It cannot skip error handling because the acceptance criteria explicitly require it.

This is the workflow the spec is designed for. The spec doesn't replace the agent. Rather, it removes the decisions from the agent's hands and puts them in yours, before the work starts.

Saving the Spec for Later

If you want to move toward Spec-Anchored development – where the spec lives in the repository – save the output to a specs/ directory in your project:

# Create specs directory
mkdir -p specs
 
# Save your spec
# Paste the output into specs/cli-capture.md

When requirements change, update the spec and re-prompt the agent to realign the implementation. The spec becomes the source of truth, not the code comments.

Where to Go Next

Try it on your next feature before you write a line of code. The assumptions it flags will tell you something about your feature you hadn't consciously decided yet – and correcting the HIGH-impact ones before you hand anything to an agent is the whole point. Skipping that step is the same as prompting directly.

If your project is growing, move toward Spec-Anchored. Save specs in your repository under specs/. When a new contributor joins or an agent starts a session cold, the specs give them the decisions that got made without requiring them to reverse-engineer the code.

The strongest ongoing challenge to this workflow is Gabriella Gonzalez's argument that detailed specs become code. If your specs are getting implementation-specific, you've crossed a line. Pull back to decisions – "only authenticated users can trigger this" – and leave implementation to the agent. The spec's job is to name what the agent would have guessed wrong, not to write the feature in prose.

The Agent Skills standard now works across Claude Code, GitHub Copilot, Cursor, and Gemini CLI. The spec-writer repo is at github.com/dannwaneri/spec-writer.

The irony of spending 64% of a Claude budget building a token-efficiency tool is real. But the spec surfaced four decisions on a twelve-word prompt. The fourth one – the deduplication key assumption – would have produced a bug that worked perfectly until a session got renamed.

That's not a hallucination. That's the agent being exactly as helpful as the prompt allowed.

The spec is how you raise the ceiling on what "helpful" means.

One of the major improvements has been a properly automated CI/CD pipeline flow that gives us seamless automation, continuous integration, and continuous deployment.

In this article, I'll break down how you can automate and build a production ready CI/CD pipeline for your Flutter application using GitHub Actions.

Note that there are other ways to do this, like with Codemagic (built specifically for Flutter apps – which I'll cover in a subsequent tutorial), but in this article we'll focus on GitHub Actions instead.

Table of Contents

1. The Typical Workflow

2. Prerequisites

3. Pipeline Architecture

4. Writing the Workflows

   • The Helper Scripts

     • generate_config.sh

     • quality_gate.sh

     • upload_symbols.sh

   • PR Quality Gate (pr_checks.yml)

   • Android CI/CD Pipeline (android.yml)

   • iOS CI/CD Pipeline (ios.yml)

5. Secrets and Configuration Reference

6. End-to-End Flow

7. Conclusion

The Typical Workflow

First, let's define the common approach to deploying production-ready Flutter apps.

The development team does their work on local, pushes to the repository for merge or review, and eventually runs flutter build apk or flutter build appbundle to generate the apk file. This then gets shared with the QA team manually, or deployed to Firebase app distribution for testing. If it's a production move, the app bundle is submitted to the Google Play store for review and then deployed.

This process is often fully manual with no automated checks, validation, or control over quality, speed, and seamlessness. Manually shipping a Flutter app starts out relatively simply, but can quickly and quietly turn into a liability. You run flutter build, switch configs, sign the build, upload it somewhere, and hope you didn’t mix up staging keys with production ones.

As teams grow and release updates more and more quickly, these manual steps become real risks. A skipped quality check, a missing keystore, or an incorrect base URL deployed to production can cost hours of debugging or worse – it can affect your users.

Automating this process fully involves some high level configuration and predefined scripting. It completely takes control of the deployment process from the moment the developer raised a PR into the common or base branch (for example, the develop branch).

This automated process takes care of everything that needs to be done – provided it has been predefined, properly scripted, and aligns with the use case of the team.

What we'll do here:

In this tutorial, we'll build a production-grade CI/CD pipeline for a Flutter app using GitHub Actions. The pipeline automates the entire lifecycle: pull-request quality checks, environment-specific configuration injection, Android and iOS builds, Firebase App Distribution for testers, Sentry symbol uploads, and final deployment to the Play Store and App Store.

By the end, every release – from a developer opening a PR to the final build landing in users' hands – will be fully automated, with no one touching a terminal.

Prerequisites

Before starting, you should have:

1. A Flutter app with working Android and iOS builds

2. Basic familiarity with GitHub Actions (workflows and jobs)

3. A Firebase project with App Distribution enabled

4. A Sentry project for error tracking

5. A Google Play Console app already created

6. An Apple Developer account with App Store Connect access

7. Fastlane configured for your iOS project

8. Basic Bash knowledge (I’ll explain the important parts)

Pipeline Architecture

In this guide, we'll be building a CI/CD pipeline with very precise instructions and use cases. These use cases determine the way your pipeline is built.

For this tutorial, we'll use this use case:

I want to automate the workflow on my development team based on the following criteria:

1. When a developer on the team raises a PR into the common working branch develop in most cases), a workflow is triggered to run quality checks on the code. It only allows the merge to happen if all checks (like tests coverage, quality checks, and static analysis) pass.

2. Code that's moving from the develop branch to the staging branch goes through another workflow that injects staging configurations/secret keys, does all the necessary checks, and distributes the application for testing on Firebase App Distribution for android as well as Testflight for iOS.

3. Code that's moving from the staging to the production branch goes through the production level workflow which involves apk secured signing, production configuration injection, running tests to ensure nothing breaks, Sentry analysis for monitoring, and submission to App Store Connect as well as Google Play Console.

These are our predefined conditions which help with the construction of our workflows.

Writing the Workflows

We'll split this pipeline into three GitHub Actions workflows.

We'll also be taking it a notch higher by creating three helper .sh scripts for a cleaner and more maintainable workflow.

In your project root, create two folders:

1. .github/

2. scripts.

The .github/ folder will hold the workflows we'll be creating for each use case, while the scripts/ folder will hold the helper scripts that we can easily call in our CLI or in the workflows directly.

After this, we'll create three workflow .yaml files:

1. pr_checks.yaml

2. android.yaml

3. ios.yaml

Also in the scripts folder, let's create three .sh files:

1. generate_config.sh

2. quality_checks.sh

3. upload_symbols.sh

.github/
  workflows/
    pr_checks.yml
    android.yml
    ios.yml

scripts/
  generate_config.sh
  quality_checks.sh
  upload_symbols.sh

This workflow architecture ensures that a push to develop automatically produces a tester build. Also, merging to production ships directly to the stores without manual commands or config changes.

The scripts live outside the YAML on purpose. This lets you run the same logic locally.

The Helper Scripts

The scripts form the backbone of the pipeline. Each one has a single responsibility and is reused across workflows.

Instead of cramming logic into YAML, we'll move it into reusable scripts. This keeps workflows clean and lets you run the same logic locally. Let's go through each one now.

Script #1: generate_config.sh

Injecting secrets safely is one of the hardest CI/CD problems in mobile apps.

The strategy:

• Commit a Dart template file with placeholders

• Replace placeholders at build time using secrets from GitHub Actions

• Never commit real credentials

#!/usr/bin/env bash
set -euo pipefail


ENV_NAME=${1:-}
BASE_URL=${2:-}
ENCRYPTION_KEY=${3:-}

TEMPLATE="lib/core/env/env_ci.dart"
OUT="lib/core/env/env_ci.g.dart"

if [ -z "\(ENV_NAME" ] || [ -z "\)BASE_URL" ] || [ -z "$ENCRYPTION_KEY" ]; then
  echo "Usage: $0 <env-name> <base-url> <encryption-key>"
  exit 2
fi

sed -e "s|<<BASE_URL>>|$BASE_URL|g" \
    -e "s|<<ENCRYPTION_KEY>>|$ENCRYPTION_KEY|g" \
    -e "s|<<ENV_NAME>>|$ENV_NAME|g" \
    "\(TEMPLATE" > "\)OUT"

echo "Generated config for $ENV_NAME"

This script is responsible for injecting environment-specific configuration into the Flutter app at build time, without ever committing secrets to source control.

Let’s walk through it carefully.

1. Shebang: Choosing the Shell

#!/usr/bin/env bash

This line tells the system to execute the script using Bash, regardless of where Bash is installed on the machine.

Using /usr/bin/env bash instead of /bin/bash makes the script more portable across local machines, GitHub Actions runners, and Docker containers.

2. Fail Fast, Fail Loud

set -euo pipefail

This is one of the most important lines in the script.

It enables three strict Bash modes:

• -e: Exit immediately if any command fails

• -u: Exit if an undefined variable is used

• -o pipefail: Fail if any command in a pipeline fails, not just the last one

This matters in CI because silent failures are dangerous, partial config generation can break production builds, and CI should stop immediately when something is wrong.

This line ensures that no broken config ever makes it into a build.

3. Reading Input Arguments

ENV_NAME=${1:-}
BASE_URL=${2:-}
ENCRYPTION_KEY=${3:-}

These lines read positional arguments passed to the script:

• $1: Environment name (dev, staging, production)

• $2: API base URL

• $3: Encryption or API key

The ${1:-} syntax means:

“If the argument is missing, default to an empty string instead of crashing.”

This works hand-in-hand with set -u , we control the failure explicitly instead of letting Bash explode unexpectedly.

4. Defining Input and Output Files

TEMPLATE="lib/core/env/env_ci.dart"
OUT="lib/core/env/env_ci.g.dart"

Here we define two files:

• Template file (env_ci.dart)

  • Contains placeholder values like <<BASE_URL>>

  • Safe to commit to Git

• Generated file (env_ci.g.dart)

  • Contains real environment values

  • Must be ignored by Git (.gitignore)

At the heart of this approach are two Dart files with very different responsibilities. They may look similar, but they play completely different roles in the system.

env.ci.dart:

// lib/core/env/env_ci.dart

class EnvConfig {
  static const String baseUrl = '<<BASE_URL>>';
  static const String encryptionKey = '<<ENCRYPTION_KEY>>';
  static const String environment = '<<ENV_NAME>>';
}

This file is safe, static, and version-controlled. It contains placeholders, not real values.

Some of its key characteristics are:

• Contains no real secrets

• Uses obvious placeholders (<<BASE_URL>>, etc.)

• Safe to commit to Git

• Reviewed like normal source code

• Serves as the single source of truth for required config fields

Think of this file as a contract:

“These are the configuration values the app expects at runtime.”

env.ci.g.dart:

This file is created at build time by generate_config.sh. After substitution, it looks like this:

// lib/core/env/env_ci.g.dart
// GENERATED FILE — DO NOT COMMIT

class EnvConfig {
  static const String baseUrl = 'https://staging.api.example.com';
  static const String encryptionKey = 'sk_live_xxxxx';
  static const String environment = 'staging';
}

Key characteristics:

• Contains real environment values

• Generated dynamically in CI

• Differs per environment (dev / staging / production)

• Must never be committed to source control

This file exists only on a developer’s machine (if generated locally), inside the CI runner during a build. Once the job finishes, it disappears.

.gitignore:

To guarantee the generated file never leaks, it must be ignored:

Why This Separation Is Critical

This design solves several hard problems at once.

Security:

• Secrets live only in GitHub Actions secrets

• They never appear in the repository

• They never appear in PRs

• They never appear in Git history

Environment Isolation:

Each environment gets its own generated config:

• develop: dev API

• staging: staging API

• production: production API

The same codebase behaves differently without branching logic in Dart.

Deterministic Builds:

Every build is fully reproducible, fully automated, and explicit about which environment it targets.

There are no “it worked locally” scenarios.

5. Validating Required Arguments

if [ -z "\(ENV_NAME" ] || [ -z "\)BASE_URL" ] || [ -z "$ENCRYPTION_KEY" ]; then
  echo "Usage: $0 <env-name> <base-url> <encryption-key>"
  exit 2
fi

This block enforces correct usage.

• -z checks whether a variable is empty

• If any required argument is missing:

  • A helpful usage message is printed

  • The script exits with a non-zero status code

• 0: success

• 1+: failure

• 2 conventionally means incorrect usage

In CI, this immediately fails the job and prevents an invalid build.

6. Injecting Environment Values

sed -e "s|<<BASE_URL>>|$BASE_URL|g" \
    -e "s|<<ENCRYPTION_KEY>>|$ENCRYPTION_KEY|g" \
    -e "s|<<ENV_NAME>>|$ENV_NAME|g" \
    "\(TEMPLATE" > "\)OUT"

This is the heart of the script.

What’s happening here:

1. sed performs stream editing: it reads text, transforms it, and outputs the result

2. Each -e flag defines a replacement rule:

   • Replace <<BASE_URL>> with the actual API URL

   • Replace <<ENCRYPTION_KEY>> with the real key

   • Replace <<ENV_NAME>> with the environment label

3. The transformed output is written to env_ci.g.dart

This entire operation happens at build time:

• No secrets are committed

• No secrets are logged

• No secrets persist beyond the CI run

7. Success Feedback

echo "Generated config for $ENV_NAME"

This line provides a clear success signal in CI logs.

It answers three important questions instantly:

• Did the script run?

• Did it finish successfully?

• Which environment was generated?

In long CI logs, these small confirmations matter.

Alright, now let's move on to the second script.

Script #2: quality_gate.sh

This script defines what “good code” means for your team.

#!/usr/bin/env bash
set -euo pipefail

echo "Running quality checks"

dart format --output=none --set-exit-if-changed .
flutter analyze
flutter test --no-pub --coverage

if command -v dart_code_metrics >/dev/null 2>&1; then
  dart_code_metrics analyze lib --reporter=console || true
fi

echo "Quality checks passed"

Lets break down this script bit by bit.

1. Start & End Log Markers

echo "Running quality checks"
...
echo "Quality checks passed"

These two lines act as visual boundaries in CI logs.

In large pipelines (especially when Android and iOS jobs run in parallel), logs can be very noisy. Clear markers:

• Help developers quickly find the quality phase

• Make debugging faster

• Confirm that the script completed successfully

The final success message only prints if everything above it passed, because set -e would have terminated the script earlier on failure.

So this line effectively means: All quality gates passed. Safe to proceed.

2. Running the Test Suite

flutter test --no-pub --coverage

This line executes your entire Flutter test suite.

Let’s break it down carefully.

1. flutter test

This runs unit tests, widget tests, and any test under the test/ directory. If any test fails, the command exits with a non-zero status code.

Because we enabled set -e earlier, that immediately stops the script and fails the CI job.

2. --coverage

This flag generates a coverage report at:

coverage/lcov.info

This file can later be uploaded to Codecov, used to enforce minimum coverage thresholds, and tracked over time for quality improvement.

Even if you’re not enforcing coverage yet, generating it now future-proofs your pipeline.

3. Optional Code Metrics

if command -v dart_code_metrics >/dev/null 2>&1; then
  dart_code_metrics analyze lib --reporter=console || true
fi

This block is intentionally designed to be optional and non-blocking.

Step 1 – Check If the Tool Exists:

command -v dart_code_metrics >/dev/null 2>&1

This checks whether dart_code_metrics is installed.

• If installed, proceed

• If not installed, skip silently

The redirection:

• >/dev/null hides normal output

• 2>&1 hides errors

This makes the script portable:

• Developers without the tool can still run the script

• CI can enforce it if configured

Step 2 – Run Metrics (Soft Enforcement):

dart_code_metrics analyze lib --reporter=console || true

This analyzes the lib/ directory and prints results in the console.

The important part is:

|| true

Because we enabled set -e, any failing command would normally stop the script.

Adding || true overrides that behavior:

• If metrics report issues,

• The script continues,

• CI does not fail.

Why design it this way? Because metrics are often gradual improvements, technical debt indicators, or advisory rather than blocking.

You can later remove || true to make metrics mandatory.

4. Final Success Message

echo "✅ Quality checks passed"

This line only executes if formatting passed, static analysis passed, and tests passed.

If you see this in CI logs, it means the branch has successfully cleared the quality gate. It’s your automated approval before deployment steps begin.

What This Script Guarantees

With this in place, every branch must satisfy:

• Clean formatting

• No analyzer errors

• Passing tests

• (Optional) Healthy metrics

That’s how you move from “We try to maintain quality” to “Quality is enforced automatically.”

Alright, on to the third script.

Script #3: upload_symbols.sh (Sentry)

This script is responsible for uploading obfuscation debug symbols to Sentry so production crashes remain readable.

#!/usr/bin/env bash
set -euo pipefail

RELEASE=${1:-}

[ -z "$RELEASE" ] && exit 2

if ! command -v sentry-cli >/dev/null 2>&1; then
  exit 0
fi

sentry-cli releases new "$RELEASE" || true

sentry-cli upload-dif build/symbols || true

sentry-cli releases finalize "$RELEASE" || true

echo "✅ Symbols uploaded for release $RELEASE"

Let's go through it step by step.

1. Reading the Release Identifier

RELEASE=${1:-}

This reads the first positional argument passed to the script.

When you call the script in CI, it typically looks like:

./scripts/upload_symbols.sh $(git rev-parse --short HEAD)

So $1 becomes the short Git commit SHA.

Using ${1:-} ensures:

• If no argument is passed, the variable becomes an empty string

• The script does not crash due to set -u

This release value ties the uploaded symbols, deployed build, and crash reports all to the exact same commit. This linkage is critical for production debugging.

2. Validating the Release Argument

[ -z "$RELEASE" ] && exit 2

This is a compact validation check.

• -z checks whether the string is empty

• If it is empty → exit with status code 2

Conventionally:

• 0 = success

• 1+ = failure

• 2 = incorrect usage

This prevents symbol uploads from running without a release identifier, which would break traceability in Sentry.

3. Checking If sentry-cli Exists

if ! command -v sentry-cli >/dev/null 2>&1; then
  exit 0
fi

This block checks whether the sentry-cli tool is available in the environment.

What’s happening:

• command -v sentry-cli checks if it exists

• >/dev/null 2>&1 suppresses all output

• ! negates the condition

So this reads as: "If sentry-cli is NOT installed, exit successfully."

Why exit with 0 instead of failing?

Because not every environment needs symbol uploads. Also, dev builds may not install Sentry, and you don’t want CI to fail just because Sentry isn’t configured.

This makes symbol uploading environment-aware and optional.

Production environments can install sentry-cli, while dev environments skip it cleanly.

4. Creating a New Release in Sentry

sentry-cli releases new "$RELEASE" || true

This tells Sentry: “A new release exists with this version identifier.”

Even if the release already exists, the script continues because of:

|| true

This prevents the build from failing if:

• The release was already created

• The command returns a non-critical error

The goal is resilience, not strict enforcement.

5. Uploading Debug Information Files (DIFs)

sentry-cli upload-dif build/symbols || true

This is the core step.

build/symbols is generated when you build Flutter with:

--obfuscate --split-debug-info=build/symbols

When you obfuscate Flutter builds:

• Method names are renamed

• Stack traces become unreadable

The symbol files allow Sentry to reverse-map obfuscated stack traces and show readable crash reports.

Without this step, production crashes look like:

a.b.c.d (Unknown Source)

With this step, you get:

AuthRepository.login()

Again, || true ensures the build doesn’t fail if:

• The directory doesn’t exist

• No symbols were generated

• Upload encounters a transient issue

Symbol uploads should not block deployment.

6. Finalizing the Release

sentry-cli releases finalize "$RELEASE" || true

This marks the release as complete in Sentry.

Finalizing signals:

• The release is deployed

• It can begin aggregating crash reports

• It’s ready for production monitoring

Like the previous steps, this is soft-failed with || true to keep CI robust.

What This Script Guarantees

When everything is configured correctly:

1. Production build is obfuscated

2. Debug symbols are generated

3. Symbols are uploaded to Sentry

4. Crashes map back to real source code

5. Release version matches commit SHA

That’s production-grade crash observability.

Now that we've gone through the three helper scripts we've created to optimize and enhance this process, lets now dive into the three workflow .yaml files we're going to create.

Workflow #1: PR_CHECKS.YML

This workflow will be designed to help ensure a certain standard is met once a PR is raised into a certain common or base branch. This will ensure that all quality checks in the incoming code pass before allowing any merge into the base branch.

This is basically a gate that verifies the quality of the code that's about to be merged into the base branch. If your pipeline allows unverified code into your base branch, then your CI becomes decorative, not protective.

Lets break down what's actually needed during every PR Check.

1. Dependency Integrity

For Flutter apps, where we manage dependencies with the pub get command, it's important to make sure that the integrity of all dependencies are confirmed – up to date as well as compatible.

Every PR should begin with:

flutter pub get

This ensures:

• pubspec.yaml is valid

• Dependency constraints are consistent

• Lockfiles are not broken

• The project is buildable in a clean environment

If this fails, the branch is not deployable.

2. Static Analysis

This ensures code quality and architecture integrity. Static analysis helps prevent common issues like forgotten await, dead code, null safety violations, async misuse, and so on.

Most production bugs aren't business logic errors – they're structural carelessness. Static analysis helps enforce consistency automatically, so code reviews focus on intent, not linting.

flutter analyze --fatal-infos --fatal-warnings

3. Formatting

This command ensures that your code is properly formatted based on your organization's coding standard and policies.

dart format --output=none --set-exit-if-changed .

4. Tests

This runs the unit, widget and business logic tests to ensure quality and avoid regression leaks, silent behavior changes and feature drift.

flutter test --coverage

5. Test Coverage Enforcement

Ideally, running tests is not enough. Your workflow should also enforce a minimum threshold:

if [ \((lcov --summary coverage/lcov.info | grep lines | awk '{print \)2}' | sed 's/%//') -lt 70 ]; then
  echo "Coverage too low"
  exit 1
fi

The command above ensures that a minimum test coverage of 70% is met, with this quality becomes measurable.

The five commands above must be checked (at least) for a quality gate to guarantee code quality, security, and integrity.

Now here is the full pr_checks.yml file:

name: PR Quality Gate

on:
  pull_request:
    branches: develop
    types: [opened, synchronize, reopened, ready_for_review]

jobs:
  pr-checks:
    name: Run quality checks on this pull request
    runs-on: ubuntu-latest

    steps:
      - name: Checkout code
        uses: actions/checkout@v2

      - name: Setup Java
        uses: actions/setup-java@v1
        with:
          java-version: "12.x"

      - name: Setup Flutter
        uses: subosito/flutter-action@v1
        with:
          channel: "stable"

      - name: Install dependencies
        run: flutter pub get

      - name: Run quality checks
        run: ./scripts/quality_checks.sh

      - name: Notify Team (Success)
        if: success()
        run: |
          echo "PR Quality Checks PASSED"
          echo "PR: ${{ github.event.pull_request.html_url }}"
          echo "Branch: \({{ github.head_ref }} → \){{ github.base_ref }}"
          echo "By: @${{ github.actor }}"
          echo "Team notification: @foluwaseyi-dev @olabodegbolu"

      - name: Notify Team (Failure)
        if: failure()
        run: |
          echo "PR Quality Checks FAILED"
          echo "PR: ${{ github.event.pull_request.html_url }}"
          echo "Branch: \({{ github.head_ref }} → \){{ github.base_ref }}"
          echo "By: @${{ github.actor }}"
          echo "Please fix the issues before requesting review 🔧"
          echo "Team notification: @foluwaseyi-dev @olabodegbolu"

Every time a developer opens (or updates) a pull request targeting the develop branch, this workflow kicks in automatically. Think of it as a bouncer at the door: no code gets through without passing inspection first.

What Triggers it?

The workflow fires on four events: when a PR is opened, synchronized (new commits pushed), reopened, or marked ready_for_review. So drafts won't trigger it – only PRs that are actually ready to be looked at.

What Does it Actually Do?

It spins up a fresh Ubuntu machine and runs five steps in sequence:

1. Checkout: pulls down the branch's code

2. Setup Java 12: installs the JDK (likely a dependency for some tooling or build process)

3. Setup Flutter (stable channel): this is a Flutter project, so it grabs the stable Flutter SDK

4. Install dependencies: runs flutter pub get to pull all Dart/Flutter packages

5. Run quality checks: executes the helper shell script (./scripts/quality_checks.sh) that we created which runs linting, tests, formatting checks, or all of the above

The Notification Layer

After the checks run, the workflow reports the verdict and it's context-aware:

• If everything passes, it logs a success message with the PR URL, branch info, and the person who opened it

• If something fails, it logs a failure message and nudges the author to fix issues before requesting a review

Both outcomes tag @foluwaseyi-dev and @olabodegbolu – the two team members responsible for staying in the loop.

This workflow enforces a "fix it before you merge it" culture. No one can merge broken code into develop without the team knowing about it.

Workflow #2: Android.yml

It's a better practice to split your workflows based on platform. This helps you properly manage the instructions regarding each platform. This is the reason behind keeping the Android workflow separate.

Unlike PR _Checks, this workflow presumes that all checks for quality and standards have been done and the code that runs this workflow already meets the required standards.

Based on our predefined use case, let's create a workflow to handle test deployments when merged to develop or staging, and production level activities when merged to production.

name: Android Build & Release

on:
  push:
    branches:
      - develop
      - staging
      - production

jobs:
  android:
    runs-on: ubuntu-latest
    env:
      FLUTTER_VERSION: 'stable'

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup Java
        uses: actions/setup-java@v3
        with:
          distribution: 'temurin'
          java-version: '11'

      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
          flutter-version: ${{ env.FLUTTER_VERSION }}

      - name: Install dependencies
        run: flutter pub get

      - name: Determine environment
        id: env
        run: |
          echo "branch=\({GITHUB_REF##*/}" >> \)GITHUB_OUTPUT
          if [ "${GITHUB_REF##*/}" = "develop" ]; then
            echo "ENV=dev" >> $GITHUB_OUTPUT
          elif [ "${GITHUB_REF##*/}" = "staging" ]; then
            echo "ENV=staging" >> $GITHUB_OUTPUT
          else
            echo "ENV=production" >> $GITHUB_OUTPUT
          fi

      # Dev uses hardcoded values no secrets needed
      - name: Generate config (dev)
        if: steps.env.outputs.ENV == 'dev'
        run: ./scripts/generate_config.sh dev "https://dev.api.example.com" "dev_dummy_key"

      # Staging and production inject real secrets
      - name: Generate config (staging/production)
        if: steps.env.outputs.ENV != 'dev'
        run: |
          if [ "${{ steps.env.outputs.ENV }}" = "staging" ]; then
            ./scripts/generate_config.sh staging \
              "${{ secrets.STAGING_BASE_URL }}" \
              "${{ secrets.STAGING_API_KEY }}"
          else
            ./scripts/generate_config.sh production \
              "${{ secrets.PROD_BASE_URL }}" \
              "${{ secrets.PROD_API_KEY }}"
          fi

      # Keystore is only needed for signed builds (staging & production)
      - name: Restore Keystore
        if: steps.env.outputs.ENV != 'dev'
        run: |
          echo "${{ secrets.ANDROID_KEYSTORE_BASE64 }}" | base64 --decode > android/app/upload-keystore.jks

      # Production builds are obfuscated + split debug info for Play Store
      - name: Build artifact
        run: |
          if [ "${{ steps.env.outputs.ENV }}" = "production" ]; then
            flutter build appbundle --release \
              --obfuscate \
              --split-debug-info=build/symbols
          else
            flutter build appbundle --release
          fi

      # Dev and staging go to Firebase App Distribution for internal testing
      - name: Upload to Firebase App Distribution
        if: steps.env.outputs.ENV == 'dev' || steps.env.outputs.ENV == 'staging'
        env:
          FIREBASE_TOKEN: ${{ secrets.FIREBASE_TOKEN }}
          FIREBASE_ANDROID_APP_ID: ${{ secrets.FIREBASE_ANDROID_APP_ID }}
          FIREBASE_GROUPS: ${{ secrets.FIREBASE_GROUPS }}
        run: |
          firebase appdistribution:distribute \
            build/app/outputs/bundle/release/app-release.aab \
            --app "$FIREBASE_ANDROID_APP_ID" \
            --groups "$FIREBASE_GROUPS" \
            --token "$FIREBASE_TOKEN"

      # Only production goes to the Play Store
      - name: Upload to Play Store
        if: steps.env.outputs.ENV == 'production'
        uses: r0adkll/upload-google-play@v1
        with:
          serviceAccountJsonPlainText: ${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT_JSON }}
          packageName: com.your.package
          releaseFiles: build/app/outputs/bundle/release/app-release.aab
          track: production

      - name: Notify Team (Success)
        if: success()
        run: |
          echo "Android Build & Release PASSED"
          echo "Environment: ${{ steps.env.outputs.ENV }}"
          echo "Branch: ${{ steps.env.outputs.branch }}"
          echo "By: @${{ github.actor }}"
          echo "Commit: ${{ github.sha }}"

      - name: Notify Team (Failure)
        if: failure()
        run: |
          echo "Android Build & Release FAILED"
          echo "Environment: ${{ steps.env.outputs.ENV }}"
          echo "Branch: ${{ steps.env.outputs.branch }}"
          echo "By: @${{ github.actor }}"
          echo "Commit: ${{ github.sha }}"
          echo "Check the logs and fix the issue before retrying"

This workflow ensures that whenever code lands on the develop, staging or production branch, this action is triggered on a fresh Ubuntu machine.

This is triggered by a simple push to any of the tracked branches, no manual intervention needed.

Let's walk through it piece by piece.

1. The Setup Phase

Before any Flutter-specific work happens, the workflow lays the foundation:

1. Checkout: grabs the latest code from the branch that triggered the run (using the more modern actions/checkout@v3).

2. Java 11 via Temurin: this is an upgrade from the first workflow we created. Instead of a generic setup-java@v1, this uses the temurin distribution which is the Eclipse's open-source JDK build. It's the current industry standard for Android toolchains.

3. Flutter (stable): this pulls the stable Flutter SDK, version pinned via an environment variable (FLUTTER_VERSION: 'stable') defined at the job level.

4. Install dependencies: this ensures we run flutter pub get to pull all packages

2. Environment Detection

This is where it gets interesting. This workflow also checks and determines the environment which will help us define the next set of instructions to run.

This command reads the branch name from GITHUB REF and maps it to its environment label which we already created in one of our helper scripts.

• develop → ENV=dev

• staging → ENV=staging

• production → ENV=production

It strips the branch name from the full ref path using \({GITHUB_REF##*/}, then writes both the branch name and the resolved ENV value to \)GITHUB_OUTPUT, making them available as named outputs (steps.env.outputs.ENV) for every subsequent step.

This means the rest of the pipeline can branch its behaviour based on which environment it's building for, different API keys, different signing configs, different targets – whatever the app needs.

3. Config Injection

With the environment resolved, the next step is injecting the right configuration into the app. This is where the generate_config.sh script we built earlier gets called directly from the workflow.

For the dev environment, hardcoded placeholder values are used. No real secrets are needed, since this build is only meant for internal developer testing:

- name: Generate config (dev)
  if: steps.env.outputs.ENV == 'dev'
  run: ./scripts/generate_config.sh dev "https://dev.api.example.com" "dev_dummy_key"

For staging and production, however, real secrets are pulled from GitHub Actions secrets and passed directly into the script:

- name: Generate config (staging/production)
  if: steps.env.outputs.ENV != 'dev'
  run: |
    if [ "${{ steps.env.outputs.ENV }}" = "staging" ]; then
      ./scripts/generate_config.sh staging \
        "${{ secrets.STAGING_BASE_URL }}" \
        "${{ secrets.STAGING_API_KEY }}"
    else
      ./scripts/generate_config.sh production \
        "${{ secrets.PROD_BASE_URL }}" \
        "${{ secrets.PROD_API_KEY }}"
    fi

Notice that these two steps use an if condition to make them mutually exclusive. Only one will ever run per job. This keeps the pipeline clean: no complicated branching logic inside the script itself, just a clear decision at the workflow level.

4. Keystore Restoration

Android requires signed builds for distribution. The signing keystore file cannot be committed to the repository for obvious security reasons, so it's stored as a Base64-encoded GitHub secret and decoded at build time.

- name: Restore Keystore
  if: steps.env.outputs.ENV != 'dev'
  run: |
    echo "${{ secrets.ANDROID_KEYSTORE_BASE64 }}" | base64 --decode > android/app/upload-keystore.jks

This step is skipped entirely for the dev environment because dev builds are unsigned debug artifacts meant purely for internal testing on Firebase App Distribution. Only staging and production builds need to be properly signed.

To encode your keystore file as a Base64 string for storing in GitHub secrets, you have to run this locally:

base64 -i upload-keystore.jks | pbcopy

This copies the encoded string to your clipboard, which you can then paste directly into your GitHub repository secrets.

5. Building the Artifact

With the environment configured and the keystore in place, the workflow builds the app bundle:

- name: Build artifact
  run: |
    if [ "${{ steps.env.outputs.ENV }}" = "production" ]; then
      flutter build appbundle --release \
        --obfuscate \
        --split-debug-info=build/symbols
    else
      flutter build appbundle --release
    fi

There's a deliberate difference between how production and non-production builds are compiled.

For production:

• --obfuscate renames method and class names in the compiled output, making it significantly harder to reverse engineer the app

• --split-debug-info=build/symbols extracts the debug symbols into a separate directory at build/symbols

These symbols are what upload_symbols.sh later ships to Sentry, so obfuscated crash reports remain readable in your monitoring dashboard.

For dev and staging, neither flag is used. This keeps build times faster and makes local debugging easier since stack traces remain human-readable.

6. Distributing to Firebase App Distribution

Once the app bundle is built, dev and staging builds are uploaded to Firebase App Distribution so testers can install them immediately:

- name: Upload to Firebase App Distribution
  if: steps.env.outputs.ENV == 'dev' || steps.env.outputs.ENV == 'staging'
  env:
    FIREBASE_TOKEN: ${{ secrets.FIREBASE_TOKEN }}
    FIREBASE_ANDROID_APP_ID: ${{ secrets.FIREBASE_ANDROID_APP_ID }}
    FIREBASE_GROUPS: ${{ secrets.FIREBASE_GROUPS }}
  run: |
    firebase appdistribution:distribute \
      build/app/outputs/bundle/release/app-release.aab \
      --app "$FIREBASE_ANDROID_APP_ID" \
      --groups "$FIREBASE_GROUPS" \
      --token "$FIREBASE_TOKEN"

Three secrets power this step:

• FIREBASE_TOKEN: the authentication token generated from firebase login:ci

• FIREBASE_ANDROID_APP_ID: the app identifier from the Firebase console

• FIREBASE_GROUPS: the tester group(s) that should receive the build notification

Once this step completes, every tester in the specified groups receives an email with a direct download link. No one needs to manually share an APK file over Slack or email.

7. Deploying to the Play Store

Production builds skip Firebase entirely and goes straight to the Google Play Store:

- name: Upload to Play Store
  if: steps.env.outputs.ENV == 'production'
  uses: r0adkll/upload-google-play@v1
  with:
    serviceAccountJsonPlainText: ${{ secrets.GOOGLE_PLAY_SERVICE_ACCOUNT_JSON }}
    packageName: com.your.package
    releaseFiles: build/app/outputs/bundle/release/app-release.aab
    track: production

This uses the r0adkll/upload-google-play GitHub Action, which handles the Google Play API interaction under the hood. The only requirements are:

• A Google Play service account with the correct permissions, stored as a JSON secret

• The correct package name matching what is registered in your Play Console

• The track set to production (you can also use internal, alpha, or beta depending on your release strategy)

Replace com.your.package with your actual application ID (the same one defined in your build.gradle file).

8. The Notification Layer

Just like the PR checks workflow, this workflow reports its outcome clearly:

- name: Notify Team (Success)
  if: success()
  run: |
    echo "Android Build & Release PASSED"
    echo "Environment: ${{ steps.env.outputs.ENV }}"
    echo "Branch: ${{ steps.env.outputs.branch }}"
    echo "By: @${{ github.actor }}"
    echo "Commit: ${{ github.sha }}"

- name: Notify Team (Failure)
  if: failure()
  run: |
    echo "Android Build & Release FAILED"
    echo "Environment: ${{ steps.env.outputs.ENV }}"
    echo "Branch: ${{ steps.env.outputs.branch }}"
    echo "By: @${{ github.actor }}"
    echo "Commit: ${{ github.sha }}"
    echo "Check the logs and fix the issue before retrying 🔧"

The success notification includes the environment, branch, actor, and shares everything needed to trace exactly what was deployed and who triggered it.

The failure notification includes the same context, with a clear call to action.

Workflow #3: iOS.yml

iOS CI/CD is more complex than Android by nature. This is because Apple's signing requirements involve certificates, provisioning profiles, and entitlements that all need to be in the right place before Xcode will produce a valid archive.

Fastlane helps us handles all of that complexity, and the workflow simply calls into it.

Here is the full ios.yml:

name: iOS Build & Release

on:
  push:
    branches:
      - develop
      - staging
      - production

jobs:
  ios:
    runs-on: macos-latest
    env:
      FLUTTER_VERSION: 'stable'

    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup Flutter
        uses: subosito/flutter-action@v2
        with:
          flutter-version: ${{ env.FLUTTER_VERSION }}

      - name: Install dependencies
        run: flutter pub get

      - name: Determine environment
        id: env
        run: |
          echo "branch=\({GITHUB_REF##*/}" >> \)GITHUB_OUTPUT
          if [ "${GITHUB_REF##*/}" = "develop" ]; then
            echo "ENV=dev" >> $GITHUB_OUTPUT
          elif [ "${GITHUB_REF##*/}" = "staging" ]; then
            echo "ENV=staging" >> $GITHUB_OUTPUT
          else
            echo "ENV=production" >> $GITHUB_OUTPUT
          fi

      - name: Generate config (dev)
        if: steps.env.outputs.ENV == 'dev'
        run: ./scripts/generate_config.sh dev "https://dev.api.example.com" "dev_dummy_key"

      - name: Generate config (staging/production)
        if: steps.env.outputs.ENV != 'dev'
        run: |
          if [ "${{ steps.env.outputs.ENV }}" = "staging" ]; then
            ./scripts/generate_config.sh staging \
              "${{ secrets.STAGING_BASE_URL }}" \
              "${{ secrets.STAGING_API_KEY }}"
          else
            ./scripts/generate_config.sh production \
              "${{ secrets.PROD_BASE_URL }}" \
              "${{ secrets.PROD_API_KEY }}"
          fi

      - name: Install Fastlane
        run: |
          cd ios
          gem install bundler
          bundle install

      - name: Import signing certificate
        if: steps.env.outputs.ENV != 'dev'
        run: |
          echo "${{ secrets.IOS_CERTIFICATE_BASE64 }}" | base64 --decode > ios/cert.p12
          security create-keychain -p "" build.keychain
          security import ios/cert.p12 -k build.keychain -P "${{ secrets.IOS_CERTIFICATE_PASSWORD }}" -T /usr/bin/codesign
          security list-keychains -s build.keychain
          security default-keychain -s build.keychain
          security unlock-keychain -p "" build.keychain
          security set-key-partition-list -S apple-tool:,apple: -s -k "" build.keychain

      - name: Install provisioning profile
        if: steps.env.outputs.ENV != 'dev'
        run: |
          echo "${{ secrets.IOS_PROVISIONING_PROFILE_BASE64 }}" | base64 --decode > profile.mobileprovision
          mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
          cp profile.mobileprovision ~/Library/MobileDevice/Provisioning\ Profiles/

      - name: Build iOS (dev)
        if: steps.env.outputs.ENV == 'dev'
        run: flutter build ios --release --no-codesign

      - name: Build & distribute to TestFlight (staging)
        if: steps.env.outputs.ENV == 'staging'
        env:
          APP_STORE_CONNECT_API_KEY_ID: ${{ secrets.APP_STORE_CONNECT_API_KEY_ID }}
          APP_STORE_CONNECT_API_ISSUER_ID: ${{ secrets.APP_STORE_CONNECT_API_ISSUER_ID }}
          APP_STORE_CONNECT_API_KEY_CONTENT: ${{ secrets.APP_STORE_CONNECT_API_KEY_CONTENT }}
        run: |
          cd ios
          bundle exec fastlane beta

      - name: Build & release to App Store (production)
        if: steps.env.outputs.ENV == 'production'
        env:
          APP_STORE_CONNECT_API_KEY_ID: ${{ secrets.APP_STORE_CONNECT_API_KEY_ID }}
          APP_STORE_CONNECT_API_ISSUER_ID: ${{ secrets.APP_STORE_CONNECT_API_ISSUER_ID }}
          APP_STORE_CONNECT_API_KEY_CONTENT: ${{ secrets.APP_STORE_CONNECT_API_KEY_CONTENT }}
        run: |
          cd ios
          bundle exec fastlane release

      - name: Upload Sentry symbols (production only)
        if: steps.env.outputs.ENV == 'production'
        env:
          SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
          SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
          SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
        run: ./scripts/upload_symbols.sh $(git rev-parse --short HEAD)

      - name: Notify Team (Success)
        if: success()
        run: |
          echo "iOS Build & Release PASSED"
          echo "Environment: ${{ steps.env.outputs.ENV }}"
          echo "Branch: ${{ steps.env.outputs.branch }}"
          echo "By: @${{ github.actor }}"
          echo "Commit: ${{ github.sha }}"

      - name: Notify Team (Failure)
        if: failure()
        run: |
          echo "iOS Build & Release FAILED"
          echo "Environment: ${{ steps.env.outputs.ENV }}"
          echo "Branch: ${{ steps.env.outputs.branch }}"
          echo "By: @${{ github.actor }}"
          echo "Commit: ${{ github.sha }}"
          echo "Check the logs and fix the issue before retrying 🔧"

Let's walk through what is different about this workflow compared to that of android.

1. MacOS Runner

runs-on: macos-latest

This is the major difference.

iOS builds require Xcode, which only runs on macOS. GitHub Actions provides hosted macOS runners, but they are significantly more expensive in terms of compute minutes than Ubuntu runners. Just keep that in mind when thinking about build frequency.

No Java setup is needed here. Flutter on iOS compiles through Xcode directly, so the toolchain requirements are different.

2. Installing Fastlane

- name: Install Fastlane
  run: |
    cd ios
    gem install bundler
    bundle install

Fastlane is a Ruby-based automation tool that handles certificate management, building, and uploading to TestFlight and the App Store.

This step navigates into the ios/ directory and installs Fastlane along with all its dependencies as defined in the project's Gemfile.

Your ios/Gemfile should look something like this:

source "https://rubygems.org"

gem "fastlane"

And your ios/fastlane/Fastfile should define at minimum two lanes: one for staging (TestFlight) and one for production (App Store):

default_platform(:ios)

platform :ios do
  lane :beta do
    build_app(scheme: "Runner", export_method: "app-store")
    upload_to_testflight(skip_waiting_for_build_processing: true)
  end

  lane :release do
    build_app(scheme: "Runner", export_method: "app-store")
    upload_to_app_store(force: true, skip_screenshots: true, skip_metadata: true)
  end
end

3. Certificate and Provisioning Profile Setup

This is the step that trips most teams up the first time. Apple's code signing requires two things to be present on the machine:

1. The signing certificate (a .p12 file)

2. The provisioning profile

Both are stored as Base64-encoded GitHub secrets and restored at build time.

- name: Import signing certificate
  if: steps.env.outputs.ENV != 'dev'
  run: |
    echo "${{ secrets.IOS_CERTIFICATE_BASE64 }}" | base64 --decode > ios/cert.p12
    security create-keychain -p "" build.keychain
    security import ios/cert.p12 -k build.keychain -P "${{ secrets.IOS_CERTIFICATE_PASSWORD }}" -T /usr/bin/codesign
    security list-keychains -s build.keychain
    security default-keychain -s build.keychain
    security unlock-keychain -p "" build.keychain
    security set-key-partition-list -S apple-tool:,apple: -s -k "" build.keychain

Breaking this down step by step:

• Decodes the Base64 certificate and write it to cert.p12

• Creates a temporary keychain called build.keychain with an empty password

• Imports the certificate into that keychain, granting codesign access

• Sets it as the default keychain so Xcode finds it automatically

• Unlocks the keychain so it can be used non-interactively

• Sets partition list to allow access without repeated prompts

The provisioning profile step is simpler:

- name: Install provisioning profile
  if: steps.env.outputs.ENV != 'dev'
  run: |
    echo "${{ secrets.IOS_PROVISIONING_PROFILE_BASE64 }}" | base64 --decode > profile.mobileprovision
    mkdir -p ~/Library/MobileDevice/Provisioning\ Profiles
    cp profile.mobileprovision ~/Library/MobileDevice/Provisioning\ Profiles/

It decodes the profile and copies it into the exact directory where Xcode expects to find provisioning profiles on any macOS system.

To encode your certificate and profile locally, you can run these:

base64 -i Certificates.p12 | pbcopy   # for the certificate
base64 -i YourApp.mobileprovision | pbcopy   # for the provisioning profile

4. Building for Each Environment

Dev builds skip signing entirely. They're built without code signing just to verify the project compiles correctly on a clean machine:

- name: Build iOS (dev)
  if: steps.env.outputs.ENV == 'dev'
  run: flutter build ios --release --no-codesign

Staging builds go through Fastlane's beta lane, which builds and uploads to TestFlight. Production builds go through Fastlane's release lane, which submits directly to App Store Connect.

Both staging and production steps consume the same three App Store Connect API key secrets: the key ID, the issuer ID, and the key content itself.

Fastlane uses these to authenticate with Apple's API without requiring a manual Apple ID login.

5. Sentry Symbol Upload

On production iOS builds, the upload_symbols.sh script runs after the build completes, passing the current short commit SHA as the release identifier:

- name: Upload Sentry symbols (production only)
  if: steps.env.outputs.ENV == 'production'
  env:
    SENTRY_AUTH_TOKEN: ${{ secrets.SENTRY_AUTH_TOKEN }}
    SENTRY_ORG: ${{ secrets.SENTRY_ORG }}
    SENTRY_PROJECT: ${{ secrets.SENTRY_PROJECT }}
  run: ./scripts/upload_symbols.sh $(git rev-parse --short HEAD)

This is the same script explained earlier in the helper scripts section. It creates a Sentry release, uploads the debug information files, and finalizes the release. Any production crash from this point forward will map back to real, readable source code in your Sentry dashboard.

Secrets and Configuration Reference

For this entire pipeline to work, you need to configure the following secrets in your GitHub repository. Go to Settings → Secrets and variables → Actions → New repository secret to add each one.

Shared (used across environments):

Staging:

Production:

Android:

iOS:

None of these values should ever appear in your codebase. If any secret is accidentally committed, rotate it immediately.

End-to-End Flow

With all three workflows in place, here is exactly what happens from the moment a developer opens a pull request to the moment a user receives an update:

1. Developer Opens a PR into develop

The pr_checks.yml workflow fires. It runs formatting checks, static analysis, and the full test suite. If anything fails, the PR cannot be merged and the team is notified immediately. The developer fixes the issues and pushes again, which triggers a fresh run.

2. PR is Approved and Merged into develop

The android.yml and ios.yml workflows both fire on the push event. They detect the environment as dev, inject placeholder config, build unsigned artifacts, and upload them to Firebase App Distribution. Testers receive an email and can install the build on their devices within minutes – no one shared a file manually.

3. develop is Merged into staging

Both platform workflows fire again. This time the environment resolves to staging. Real secrets are injected, builds are properly signed, and the artifacts go to Firebase App Distribution (Android) and TestFlight (iOS). QA begins testing the staging build against the staging API.

4. staging is merged into production

Both workflows fire one final time. Production secrets are injected, builds are obfuscated and signed, debug symbols are uploaded to Sentry, and the final artifacts are submitted to the Google Play Store and App Store Connect. The release goes live on Apple and Google's review timelines with no further human intervention required.

From that first PR to a production submission, not a single command was run manually.

Conclusion

Building this pipeline is an upfront investment that pays off from the very first release cycle. What used to be a sequence of error-prone manual steps building locally, signing, uploading, switching configs, and hoping nothing was mixed up is now a fully automated, auditable, and repeatable process that runs the moment code moves between branches.

The architecture we built here does more than just automate builds. The PR quality gate enforces team standards consistently, so code review becomes a conversation about intent rather than a hunt for formatting issues. The environment-aware config injection eliminates an entire class of production incidents where staging keys made it into a live release. The Sentry symbol upload means your team can debug production crashes with full source visibility even from an obfuscated binary.

Every piece of this pipeline also runs locally. The helper scripts in the scripts/ folder are plain Bash so you can call them from your terminal the same way CI calls them. This eliminates the frustrating cycle of pushing a commit just to test a pipeline change.

As your team grows, this foundation scales with you. You can extend the pr_checks.yml to enforce code coverage thresholds, add a performance benchmarking job, or introduce a dedicated security scanning step. You can extend the platform workflows to support multiple flavors, multiple Firebase projects, or staged rollouts on the Play Store. The architecture stays the same – you're just adding new steps to an already working system.

This ensures that standards are met, code quality remains high, you have a proper team structure, clear process and automated post development activities are in place – and at the end of the day, you'll have an optimized engineering approach that will help your team in so many ways.

I have seen too many founders who are smart, legit, and ambitious get ghosted by investors simply because they couldn't walk through their unit economics.

It's not personal. It's math.

So here it is: Numbers that will either carry your pitch or quietly kill it, explained by someone who has sat through them time and time again, with examples, and no fluff.

Here’s what we’ll cover:

• 1. Burn Rate: How Fast Are You Lighting Your Cash on Fire?

• 2. Cash Runway: How Long Before You Run Out of Cash?

• 3. CAC (Customer Acquisition Cost): How Much Does it Cost to Convince Someone to Pay You?

• 4. Customer Lifetime Value (LTV): How Much is One Customer Worth Over Time?

• 5. Gross Profit Margin: What Do You Actually Keep After Delivering Your Service or Product?

• 6. Monthly / Annual Recurring Revenue (MRR / ARR)

• 7. Churn Rate: How Fast Are Your Users Leaving

• 8. Payback Period: How Long Before You Recover Your CAC?

• 9. Earnings Before Interest, Taxes, Depreciation, and Amortization (EBITDA)

• 10. Valuation: What’s Your Company Worth – and What Supports that Number?

• Real Talk Before You Close That Tab

  • Real Experience

  • Why This Matters

• Conclusion and Final Thoughts

1. Burn Rate: How Fast Are You Lighting Your Cash on Fire?

Burn rate is the speed at which a startup is spending its cash. Basically, how fast are you consuming your venture capital to cover over overhead until you generate positive cash flow from operations? It’s a measure of negative cash flow.

If you’re spending $80K a month to keep the lights on (payroll, AWS, your workspace snacks, and so on), that’s how much cash you’re burning each month. But many startups calculate two different burn rates: gross burn (how much cash you’re spending, ignoring any revenue), and net burn (monthly operating experiences minus any cash you take in each month). Net burn basically measures how fast your cash is shrinking, and it’s often what investors care more about.

Real talk: investors want to know when the plane runs out of fuel before they board. Thats what this metric helps them understand – how fast you’re going through the money you have.

At some point, if a company has a high burn rate, it has to reduce structural costs by cutting expenditures on labor, rent, marketing, and/or capital equipment. The burn rate is an important metric for any company, but it's particularly important for startups that aren't yet generating revenue. It tells managers and investors how fast the company is spending its capital

Watch this video to understand more about Burn Rate.

2. Cash Runway: How Long Before You Run Out of Cash?

Cash runway tells how long a startup can continue to operate at a certain burn rate until they are out of cash. For startups without revenue, you can calculate this by dividing available cash by total monthly expenses. Available cash is defined as the funds that are accessible now or can be accessed at a later time relatively quickly to pay for expenses.

When you’re making this calculation, it’s important to not include any anticipated fundraising and other uncertain sources of capital.

Actively managing cash runway is crucial for startup survival and growth. With a significant percentage of startups failing due to cash shortages, founders need to closely monitor their cash burn rate and runway.

The length of runway needed varies based on factors including the startup’s stage, industry, and milestones. In tighter venture capital markets, startups should plan for longer runways and consider strategies such as increasing revenue, reducing expenses, or raising additional capital. Regularly updating financial models and understanding metrics like the burn multiple can help you make informed decisions to extend your runway and align your growth ambitions with financial stability.

While it’s a simple calculation at face value, a cash runway analysis is nuanced and unique to every startup and can be impacted by a multitude of circumstances.

To calculate this, you just divide your total cash reserves by the amount you’re spending each month. Say you’ve got $250K in the bank and you’re spending $50K/month: 250/50 = 5. So you’ve got 5 months. Not 6. Not “it depends” – 5. That’s your runway.

Investors ask “If we don’t fund you, how long do you survive?” If you don’t know that answer, you're not fundraising – you’re freelancing with hope.

Here is a video that explains cash runway with real world examples and the thought process behind it.

And here’s an article from JP Morgan breaking down cash runway, its importance, and what can you to to maximize it.

Burn Rate vs Runway

So, let’s just make this super clear: burn rate is simply how much you spend each month to run your operation – that is, your negative cash flow. Runway is how many months there are left before your bank balance reaches zero.

So again, why do these numbers matter?

Because burn rate tells you how quickly you need to find more revenue or funding. Runway tells investors whether you are going to still be around by the time they finish their due diligence.

They are not just numbers. They are your survival clock.

Smart founders utilize these metrics to:

• Trim the fat without cutting muscle – know what to focus on and what to let go

• Forecast hiring/fundraising deadlines – know the process and prep for it. Numbers don’t line but they sure can get you ghosted.

• Assure investors you’re not going to come knocking again in 90 days – establishing credibility is key, make an investor realize its not just a hobby, you mean business.

The goal: Extend runway without stalling momentum. Keep the plane in the air, while building a bigger engine.

3. CAC (Customer Acquisition Cost): How Much Does it Cost to Convince Someone to Pay You?

Cost of acquisition refers to the entire cost that a business incurs to obtain a new client or asset. This includes the purchase price, shipping, installation, and marketing costs for the asset acquired. CAC takes into account the total expenditure on all marketing, advertising, and sales for the period, which you then divide by the number of new customers for the period.

In this case, all the upfront costs incurred to purchase a business asset, including equipment or inventory, are part of the cost of acquisition. Cost of acquisition includes:

• Purchase price of the item

• Costs to ship it to its point of use

• Costs to install the item

• Costs to get it up and running (in the case of equipment) or ready for sale (in the case of inventory) condition

• Marketing sales teams salaries

• All sales and consulting marketing expenses geared to get new consumers should all be included

Formula:
CAC = (Total Marketing + Sales Expenses) / Number of New Customers Acquired

Say you spent $10K last month across paid ads, content creation, outbound campaigns, and sales team costs. You onboarded 100 new customers, so your CAC = $100.

But is that good?

It depends on:

• Your pricing model (one-time vs. subscription)

• Your margin (how much of that sale do you actually keep?)

• Your customer retention (how long do they stick around?)

If you’re selling a $20 product once, a $100 CAC is a non-starter. But if that customer brings in $50/month for 12 months, you’ve got a solid return.

Watch for red flags:

• CAC is rising but revenue isn’t

• You’re overly reliant on paid ads (especially if organic/referral is flat)

• You don’t know CAC by channel (averages hide leaks)

A healthy CAC is one that pays itself back quickly and can be improved over time as you optimize funnels and messaging

Here is a video that breaks down CAC for you.

4. Customer Lifetime Value (LTV): How Much is One Customer Worth Over Time?

Customer Lifetime Value is the average monetary value of each customer to your business. LTV takes into account how much a unique customer is expected to spend with your business. It’s an important metric so you know how much new customers are worth to your business over their lifespan as a customer.

Let’s say you charge $25/month. The average customer sticks around 12 months.
LTV = $300.

In this case, if your CAC is $80? You’re in the green. But if it’s $350? You’re basically paying people to hang out (and losing money on them).

Now, let’s connect this to CAC.

Say your CAC is $80. You’re doing fine – your LTV is ~4x CAC. That’s what investors want to see.

Rule of thumb: you want your LTV to be at least 3x your CAC. A 1:1 ratio means you’re barely breaking even, before operational costs and the math stops working at scale. So if you can hit a 3:1 ratio, great – and based off my experience, your business will be much more appealing if it’s closer to 5:1.

And keep in mind that different models can have different thresholds. For example, a SaaS company with low churn can afford higher CACs, while an e-commerce platform might need faster payback. And marketplaces and freemium models may have lower LTV per user, but they can often more easily offset it with volume.

If you don’t know your LTV or can’t defend it with data, it becomes hard to justify spend – and easy for investors to walk.

If you want to know more, this video walks you through the basics.

And here’s a video that beautifully explains the CAC and LTV relationship.

5. Gross Profit Margin: What Do You Actually Keep After Delivering Your Service or Product?

Gross profit margin shows the amount of money a business collects after it pays for all its expenses. It’s usually calculated as a percentage of sales. This specific metric is also referred to as the gross margin ratio.

Companies use gross margin as a measure of how production costs relate to revenue. If a company's gross margin falls because it is making less revenue, it may try to cut labor costs, find cheaper suppliers of materials, or increase prices to increase revenue.

Gross profit margins can also allow a business to measure how efficient a company is, or compare two very differently sized companies that share a common revenue stream or product

If you sell a subscription for $50/month and it costs you $10/month to host, maintain, and support it, your gross margin is 80%.

• Good: SaaS companies often hit 70–90%.

• Bad: If you're below 30%, your "scalable" business will collapse under weight.

Want to know the conceptual math behind this metric and how it differs from Profit Margin? Here is a fantastic video that easily breaks it down.

6. Monthly / Annual Recurring Revenue (MRR / ARR)

Annual recurring revenue (ARR) is revenue a company expects to see from its product and service offerings, calculated over the course of a year. Companies that sell annual subscriptions like using ARR as a sales metric to track what they anticipate making in a year.

ARR tends to be used if companies sell a product or service in the software as a service (SaaS) space, but it can also be useful in terms of streaming services, cell phone bills, and (almost) anything else with a predictable, recurring charge.

ARR is calculated annually, whereas monthly recurring revenue (MRR) is calculated monthly. MRR is useful in that it shows what’s happening on a month-to-month basis. For example, if you change your price in April, you can see the immediate effects of that change in May. MRR also helps track fluctuations in revenue based on outside factors like holiday shopping seasons and economic conditions.

In a nutshell, Monthly / Annual Recurring Revenue = predictable income.

If you’re pulling $20K/month in subscriptions, that’s $240K ARR. Simple.

What investors care about:

• • Is it growing?

    • How fast?

    • And how stable is it?

Here is a founder breaking down the metric and explaining the relationship between MRR/ARR.

7. Churn Rate: How Fast Are Your Users Leaving

The churn rate, also known as attrition rate, represents the rate at which a customer stops doing business with a company. Customer churn is typically expressed as the percentage of service subscribers that discontinue their service subscriptions within a time frame. Churn can also be expressed as the rate at which employees leave their jobs in a given time.

In order for a business to grow its number of clients, its growth rate (which takes into account new customers) must be higher than its churn rate.

The benefit of calculating a churn rate is that it can clarify how well a business is retaining its customers, which is a measure of the quality of service the business is providing and the usefulness of that service.

When a business can see its churn rate increasing from period to period, this suggests that a critical aspect of how it is running the business might be problematic or flawed.

It could be the result of:

• A faulty product(s)

• Bad customer service

• Costs exceed utility to customers

And so on.

The churn rate will indicate to a business that it needs to learn why its customers are leaving, and where it needs to adjust its business. It’s more expensive to attract new customers than it is to retain them, so reducing the churn rate can save a business resources in the future.

Real talk: Say you had 500 users at the start of the month, and you lost 50 by the end of the month. That’s 10% churn – which is high! Annualize that and…ouch. You're not growing. You're replacing.

Make sure you fix this before you fundraise. Or at least explain why churn’s high and what you’re doing to plug the holes.

Here is a video that beautifully explains Churn Rate.

8. Payback Period: How Long Before You Recover Your CAC?

The payback period is a popular tool for determining investment return. People invest money for the purpose of getting it back and generating a positive return on the money they invested. The shorter the payback period, the more beneficial the investment will be.

The payback period does not factor in the time value of money. You can determine it simply by counting the number of years until the principal paid in is returned.

This metric measures how quickly your customer pays you back for the cost of acquiring them. The payback period doesn’t take into account the total profitability of an investment. It’s just concerned with paying the investment back.

There are two common interpretations:

1. Customer-Level Payback: If your CAC is $250 and your customer pays $50/month, it’ll take 5 months to recover the acquisition cost.

2. Investment-Level Payback: You spend $100,000 on a new sales hire, tool stack, or feature. You want to know how long it takes for that investment to generate $100,000 in profit.

Both use the same principle: the shorter the payback period, the less cash you need to float your growth.

If you want a target, aim for 6 months for customer-level payback. Closer to 3-6 is ideal. Long payback periods mean you need deep pockets – or exceptional retention – to stay afloat.

Here’s a video where you can learn more.

9. Earnings Before Interest, Taxes, Depreciation, and Amortization (EBITDA)

EBITDA stands for Earning Before Interest, Taxes, Depreciation, and Amortization. You can think of this as just your company's operating profit if you wanted a very rudimentary way of referring to it.

It’s not flashy. It’s not fun. But it tells investors: “Here’s what we really make once the accounting fog clears.” and “Are we generating real profits from our actual operations?”

EBITDA is what investors look at because it is the best way of comparing apples to apples when considering startups. EBITDA can provide investors a measure of your operational health.

A negative EBITDA for an early stage company isn't going to raise any eyebrows. Just don’t act surprised when someone brings it up. You need to do that math before the pitch. But, if you have a growing early stage company that's moving from negative EBITDA to positive? Now your getting into grown folks business.

Here’s a video that explains the basics of EBITDA.

And here’s another video that explains how investors look at EBITDA and its value in determining your business’s worth.

10. Valuation: What’s Your Company Worth – and What Supports that Number?

Valuation is a focused exercise that determines the value of an asset, investment, or company. So, how much your company’s worth. And the goal is typically to determine whether that value is a fair value.

Valuations can be conducted in one of two ways:

• an absolute valuation, which evaluates a company on its own merits and entirely independently of other factors/companies, or

• a relative valuation, which evaluates the company relative to other similar firms, or assets, in the same sector or industry. This determines if the company, or asset, is worth that much relative to others.

Depending on how the analysis and conclusions are reached, there are a variety of methods and techniques used to develop valuations. And as you’d expect, there’s often significant variability between outputs (or valuations) based on the inputs and context.

While valuations are predominantly quantitatively driven, there’s often a significant subjective influence that come from the assumptions and estimates made along the way. Valuations are also subject to developing situations and events outside of the analysis or the control of the analyst – for example, earnings reports or material news, or economic news – that can result in a change to a valuation stance.

If you’re pre-revenue and you’re saying $30M because a friend raised at that, please stop. Their experience likely has nothing to do with yours.

Valuation = traction + market comps + revenue + momentum + team.

Valuation isn’t just about what you want – it’s about what you can defend.

Startups are typically valued using:

• Comparable Analysis (Comps): What similar companies are worth

• Discounted Cash Flow (DCF): Projecting future cash and discounting it back

• Revenue Multiples: Often 5x–10x for SaaS, but varies wildly

• Precedent Transactions: What investors paid in past rounds for similar startups

But that’s the math.

Here’s the messy truth: Valuation = Traction + Team + TAM (total addressable market) + Timing + Storytelling.

Hard factors:

• MRR/ARR

• Growth rate

• Churn

• CAC:LTV

• Gross margins

Soft factors:

• Founding team’s track record

• Market momentum

• Hype or scarcity

Don’t inflate. Don’t anchor to your friend’s raise. Know your comps. And show why your model is defensible, not just desirable. Inflated numbers make investors run. They don’t correct you – they just ghost you.

There are numerous books written on valuation and each technique could be its own PhD. But my role here is to give you a sneak peak into the metrics.

Here’s a basic video on valuation if you’re interested in a deeper dive.

And here’s a more detailed video course outlining different forms of valuation. Professor Damodaran from New York University is considered to be one of the aces and thought leaders when it comes to valuation. In this video course he explains stepwise and beautifully so you can understand and explore the fascinating world of valuations.

Real Talk Before You Close That Tab

Real Experience

I met a founder once – early days, rough product, but you could tell he actually cared. He wasn't trying to look good. No buzzwords. No "disrupt" talk. Just someone trying to solve something annoying and important.

He walked into the room with a twinkle. Not swagger – just that gentle intensity. We were leaning in.

Then, in the middle of the pitch, someone asked, "So what's your monthly burn?" And I swear to you, he said, "Umm... I think my co-founder has that. I haven't looked in a while."

That was it.

No freak out. No awkward pause. Just... a cluck. Like a window closing in the background.

The product? Still smart. But the moment? Gone.

Nobody was mad. Nobody laughed. We even said thank you. But nobody followed up.

Why? Because it didn't feel like a business. It felt like a maybe.

Why This Matters

I’ve seen so many versions of that same scene play out. It’s never about charisma. It’s not even about the idea, half the time.

It’s about whether the person asking for money actually knows what they’re building. Not the dream, the mechanics. The guts, nuts and bolds of the business. The ugly Excel math nobody brags about on Twitter.

Unfortunately, no simple pitch deck will do that part for you. No co-founder can answer those questions on your behalf.

If it’s your vision, own the math. If it’s your company, learn the cost of keeping it alive.

The rest? The logos, the taglines, the “go-to-market” plans?.... All of that’s just packaging.

And you don’t have to be perfect either. You just have to be in it. Eyes open. Numbers in your head.
Because if you’re asking people to believe in what you’re building, you’d better believe in the scaffolding holding it up.

So yeah, know your CAC. Your LTV. Your margins. Your churn. Not to check some box on an investor’s sheet, but to prove to yourself and the investor that the thing you’re spending your life on…has legs. That it can stand. And run.

And maybe, someday, outlast you. Maybe!

Conclusion and Final Thoughts

I hope this was helpful to you, especially if you’re a founder or aspiring founder trying to build the next big thing. While there a many more ratios and concepts, these are the crux of them.

A lot of other complex ratios and valuations are either built using these metrics or refer them in some way. And each of these metrics could be an article of its own. But I wanted to give you my top 10 run down so that you could get a head start. Numbers are very much a part of the ideation stage itself, and omitting them from your strategy could prove to be a fatal mistake.

I’ll leave you with one last video on How to Start a Start Up with Michael Seibel (Reddit, YC, Twitch) that I hope you find valuable. It lays out, in a crash course format, the mindset of a founder who has been there and done that. The fun fact is that a lot of the themes he speaks of tie in to the metrics here, directly or indirectly.

I hope this gives you a perspective of being on the other side, evaluating your hard work and passion, and I hope it sets you up for success in your next Investor Review.

I look forward to your thoughts, comments, and feedback. If this was helpful, engaging, and informative, do share it – you never know who may need it, or could benefit from it. I wish you all the very best in your funding rounds.

Until then, keep learning, unlearning, and relearning, folks.

Then I joined a real team.

Suddenly, I was introduced to this thing called Kanban – and I realized I’d been treating software like a solo art project, not a process.

If that sounds familiar, you’re in the right place.

This guide will walk you through how Kanban actually works, how developers use it to track and prioritize work, and how it can help you stay sane when juggling bugs, features, and real-world deadlines.

Without further delay, lets get into it.

Here’s what we’ll cover:

• So… What Is Kanban?

• The Classic Kanban Board: Three Simple Columns

• How Developers Use Kanban in Real Life

• Kanban vs Scrum: What’s the Difference?

• So which one should you use Scrum or Kanban?

• What Tools Do Teams Use for Kanban?

• How to Use Kanban to Manage Your Own Coding Projects

• Final Thoughts: Why Kanban Isn’t Just a Board

So… What Is Kanban?

At its core, Kanban is a visual way to manage work. It helps teams (or team members) see:

• What needs to get done

• What’s in progress

• What’s finished

• Where things are getting stuck

The concept comes from lean manufacturing, but in tech, it’s often used in Agile teams that need flexibility without the structure of Scrum sprints.

Think of Kanban like a whiteboard that tells a story. Not just what’s done, but how work flows.

The Classic Kanban Board: Three Simple Columns

So what exactly is a Kanban board? At its core, it’s a visual representation of your workflow – a board that shows all the work your team (or you, solo warrior) are juggling, and where each task stands.

It can be physical, like an actual whiteboard with sticky notes that move from one column to the next. Or digital, using tools like Trello, Jira, GitHub Projects, or Notion. The key is that it’s visual and up-to-date. You can walk into a room or open a tab and instantly understand: What’s being worked on? What’s ready to go? Where are things stuck?

It’s like having your brain on a wall, but organized. And slightly less chaotic.

The beauty of Kanban is how dead simple it is to get started. At minimum, your board has three columns:

Each task – or card – moves from left to right as it gets worked on.

Let’s say your team is building a blog platform. Your Kanban board might have cards like:

• “Create signup form”

• “Fix image upload bug”

• “Deploy staging build”

Now, while Kanban is flexible, it can absolutely be taken too far.

I’ve seen boards with more columns than a Greek temple: “Needs Review,” “Pending Client Feedback,” “QA Rework Round 2,” “Blocked but Still Hopeful,” “In Existential Limbo,” and so on. Every card had six tags, three owners, two checklists, and one migraine.

The lesson? Don’t turn your board into a bureaucratic jungle.

You don’t need to account for every edge case. Start simple: “To Do,” “In Progress,” “Review,” “Done.” These basic stages cover most workflows. If you discover a real need for something more – like a dedicated “QA” column or “Blocked” column – add it intentionally, not because you feel like your board needs to look fancy.

Remember: A Kanban board should be helpful, not overwhelming. If you spend more time managing the board than doing the work on it… it’s doing the opposite of what it’s meant to do.

How Developers Use Kanban in Real Life

Here’s how you might interact with a Kanban board on a dev team:

1. You pick up a card from “To Do” – let’s say, “Add dark mode toggle.”

2. You move it to “In Progress.”

3. When it’s ready for review, you might move it to a temporary “Review” or “Testing” column.

4. Once it’s merged, tested, and deployed, you move it to “Done.”

5. You smile, drink some coffee, and grab the next card.

That’s it. But over time, this process helps the whole team:

• Spot bottlenecks

• Prevent duplicate work

• Reduce context switching

• Keep everyone aligned

What’s a WIP Limit — And Why Should You Care?

WIP = Work In Progress. This is the most important concept to keep us in check.

One of Kanban’s key principles is limiting how many things you’re working on at once. Because guess what? Multitasking kills momentum.

A typical WIP limit might look like:

• No more than 2–3 cards per person in “In Progress” Again this is best practice, but folks do pick up a lot and then they end up being the bottleneck.

• No more than 5 tasks waiting on QA.

Why? Because when everything’s urgent, nothing gets done. WIP limits force you to finish one thing before you start more – and that’s how real velocity happens.

If there are more than 5 tasks in the “To Do” column, the team doesn’t take up new ones. Instead, everyone chips in to see how they can help unclog the bottleneck. A bottleneck is your worst enemy in Kanban, and you want to resolve it so items move smoothly on time and on target.

Here’s a video recapping key concepts.

Kanban vs Scrum: What’s the Difference?

You’ve probably heard Scrum and Kanban mentioned in the same breath – and both are popular Agile frameworks. But they’re not interchangeable.

Scrum is structured, with roles like Product Owner and Scrum Master, and work gets organized into time-boxed sprints. It’s perfect for teams that benefit from rhythm and rituals – like sprint planning, daily standups, and retrospectives.

Kanban, on the other hand, is a little looser. No official roles, no set sprint timelines. Work flows continuously, and change can happen anytime. It’s perfect for teams who need more flexibility and fewer ceremonies.

So how do they compare in practice? Let’s break it down:

Bottom line:

• Scrum is a scheduled loop. Kanban is a living flow.

• One’s a playbook. The other’s a status window.

Here’s a video on the main differences between Scrum and Kanban you can watch if you want more detail.

So which one should you use Scrum or Kanban?

So… which one should you use?

It really depends on your team, your product, and your pain points.

✔️ If you’re working on a brand-new product where requirements shift a lot, and your team thrives with structure and routines – Scrum is likely the better fit. Sprints give you a sense of pacing, and ceremonies help ensure alignment.

✔️ If you’re managing ongoing work like bug triage, tech debt, infrastructure tasks, or anything that’s more “whenever it comes in” than “we need to ship this in two weeks” – Kanban gives you flexibility and visibility without the overhead.

And yes, there’s such a thing as Scrumban – a hybrid approach where teams use visual boards and WIP limits from Kanban, but keep some of Scrum’s structure like standups and retros. It’s like Agile tapas: you get the flavors that work best for your appetite.

Here is a detailed video that’'ll teach you more about how Scrumban works in practice.

Watch the Scrumban video only when you are familiar and comfortable with both Scrum and Kanban – otherwise, you might get confused from the cross-pollination of ideas and frameworks.

I personally have never seen a Scrumban implementation thats scaled well – too many folks trying too many things and none of them work. But thats just based on my experience – it may work for you and your team. I’ll let you be the judge.

What Tools Do Teams Use for Kanban?

You’ve probably seen (or used) one already:

• Trello – Simple and great for solo or small teams

• Jira – Enterprise-level, customizable workflows

• GitHub Projects – Lightweight but powerful for devs

• ClickUp / Asana / Notion – Integrated with docs/tasks

Kanban isn’t tied to any one tool – you can use an app, a browser tab, or a whiteboard and a pack of sticky notes from the office supply closet. What matters is how you use it. But let’s walk through some of the most common tools and what they offer in a Kanban context:

🟩 Trello

Trello is probably the easiest way to start with Kanban. It gives you a simple digital board with columns and cards you can drag and drop. It’s great for devs or small teams who don’t need tons of automation – just a clean place to track work visually.

🟨 Jira

Jira is a heavyweight – and while it’s built for Scrum, it also supports robust Kanban boards. You can define custom workflows, use built-in reports like cumulative flow diagrams, enforce WIP limits, and manage team velocity. Ideal for large teams that need traceability, integrations, and permissions.

🟦 GitHub Projects

If your code lives in GitHub, GitHub Projects is a clean way to stay close to your codebase. It lets you create Kanban-style boards with issues and pull requests as cards, so you’re never toggling between tools just to track what’s in progress.

🟧 ClickUp / Asana / Notion

These are all-in-one productivity platforms. They combine Kanban boards with documentation, team chat, calendars, and reporting. If your team needs more than just “move card left to right,” these tools let you manage projects, meetings, notes, and workflows in one place.

🟪 Whiteboard + Sticky Notes

Don’t underestimate the analog approach. It’s fast. It’s visible. It’s tactile. Physically moving a task from “Doing” to “Done” gives you a sense of progress no digital tool can match. And when something’s blocked? Slap a red sticky on it and call it a day.

Bottom line: The best tool is the one your team will actually use. Fancy doesn’t beat consistent. And the actual tool doesn’t matter as much as the discipline your team has to actually use it.

How to Use Kanban to Manage Your Own Coding Projects

Even if you're not on a team yet, Kanban is great for your own workflow. Here’s how you can use it to help yourself out:

1. Create a basic 3-column board (To Do, In Progress, Done)

2. Write out every task, big or small

3. Set a WIP limit (for example, no more than 2 tasks at once)

4. Update it daily. Make it a ritual.

5. Review your flow weekly – What got stuck? What moved fast?

Example:

You’ll be shocked how much clearer your thinking gets when you can see your work. It’s simple but super powerful to visualize your work it in this way.

Final Thoughts: Why Kanban Isn’t Just a Board

Kanban isn’t just a tool – it’s a mindset.

It helps you focus. It helps your team collaborate. And it gives everyone – even non-technical folks – visibility into what’s going on.

If you’re learning to code and want to feel more confident working with others, learning Kanban is low-effort, high-impact.

So don’t wait until your first job. Start using it now – and show up to that standup with confidence.

I hope this small 101 Guide to Kanban was helpful to you all. My sole purpose to write this was to help beginner developers understand Kanban as a practical workflow system – especially for those transitioning from solo coding to collaborative, real-world development environments. It aims to demystify the methodology in a casual, beginner-friendly tone while still offering actionable guidance.

I hope you enjoyed my beginners guide to Kanban.

Until next time, keep Learning, Unlearning and Relearning, folks….

You’ve been grinding through tutorials. You've built a portfolio site, maybe deployed a few projects on GitHub. And now you're trying to land a job or join a team.

Then the interviews start.

Suddenly, people ask:

• "Are you familiar with Agile?"

• "Have you worked in a Scrum environment?"

• "What’s your experience with sprints?"

Cue the imposter syndrome. Because no one teaches this stuff in JavaScript 101.

This guide is for you.

I’ll help make the Scrum process – a very common way developers work together – make actual sense. I’ll walk you through the basics, but also tell you what developers actually do, how standups feel when you're new, and what’s expected of you when you’re no longer coding in a vacuum.

Let’s break it down.

Here’s what we’ll cover:

• What Even Is Scrum?

• The Three Roles in Scrum (and Who Does What)

• The Scrum Rhythm: What a Sprint Actually Looks Like

• Who attends the Ceremonies:

• Standups: Where You Talk Like a Human, Not a Robot

• Sprint Planning

• What’s a User Story and Why Does It Sound Like a Children’s Book?

• What Counts as “Done”? Definition of Done and Why It’s Important

• Demos, Retros, and Saying the Hard Things

• Tools You Might Encounter

• If You’re Preparing for a Job, Here’s What You Can Do

• Final Thoughts

What Even Is Scrum?

Scrum is not a tool. It’s not a software. It’s not some elite thing only PMs care about.

It’s a lightweight framework that helps software teams build things incrementally, together, in short focused cycles called sprints.

Scrum is used by everyone from FAANG teams to indie dev shops because it helps:

• Keep teams aligned

• Deliver working software fast

• Course-correct often

• Spot problems early (before they go nuclear)

It’s the opposite of the old-school “build for a year and pray it works” model.

The Three Roles in Scrum (and Who Does What)

Scrum officially defines three roles. Here's what that means in practice:

1. Product Owner (PO)

Think: Vision-holder. They decide what the team builds and why. A product owner:

• Writes user stories (think of these as feature requests written from a user’s point of view)

• Prioritizes the work

• Clarifies what success looks like

• Says “yes” or “not yet” to features

2. Scrum Master (SM)

Think: Air-traffic controller meets therapist. They make sure the process works. The are master Facilitators, like between Dev and PO’s. A Scrum Master:

• Facilitates meetings

• Removes blockers (“Your AWS access is stuck? I’ll escalate it.”)

• Coaches the team on Scrum practices

• Doesn’t manage people – manages flow

3. Developers (YOU!)

Think: Builders. You write code, test it, ship it, fix it, and improve it. You also:

• Break down stories into tasks

• Pick up work from the team board (like Jira or Trello)

• Communicate progress

• Demo what you’ve built at the end of the sprint

You might also work with designers, testers, or DevOps folks – but within Scrum, you’re all “developers” building a product together.

The Scrum Rhythm: What a Sprint Actually Looks Like

Image Source: https://www.invensislearning.com/blog/what-are-scrum-ceremonies/

Understanding the Scrum Cycle

So, what does it actually look like when a team uses Scrum to build software?

Let’s walk through a full sprint – not just the buzzwords, but what really happens when a group of humans tries to plan, build, review, and improve together. Think of this as your backstage pass to the rhythm of modern teamwork.

📦 Step 1: Build and Refine the Product Backlog

Before any coding starts, the team needs to agree on what they might build – not just this week, but in the near future too.

That’s where the Product Backlog comes in. This is a big, running list of everything the product might need – features, bug fixes, improvements, ideas, and maybe a few wild dreams. It’s like the wishlist for the product, but more organized (ideally).

The Product Owner is responsible for maintaining and prioritizing this list. They decide what’s most important to work on based on customer needs, business goals, and feedback.

But the PO doesn’t do this in isolation. Enter the Backlog Refinement meeting.

In these sessions, the Scrum Team – that’s the PO, the Scrum Master (SM), and the Developers – come together to:

• Review the most important upcoming items

• Clarify any vague or confusing parts of each task

• Break big items down into smaller, buildable pieces called user stories

• Estimate effort (how much time or complexity is involved for each story)

This meeting makes sure the team isn’t caught off guard in the sprint – that they understand the work ahead and can actually start sprinting when the time comes.

🧭 Step 2: Sprint Planning – What Are We Building This Time?

Now that we’ve got a solid backlog, it’s time to pick what to build right now.

At the start of each sprint (which typically lasts 1 to 4 weeks), the team holds a Sprint Planning meeting. This meeting sets the stage for the entire sprint – it’s like the huddle before the big game.

In Sprint Planning, the team:

• Reviews the top items from the backlog

• Discusses what can realistically be completed based on their availability and capacity

• Chooses a handful of these stories to commit to

• Defines a Sprint Goal – a simple statement that captures the purpose of this sprint

For example, the Sprint Goal might be:
🎯 “Allow users to reset their passwords.”

Every user story chosen should contribute to that goal. The collection of these stories becomes the Sprint Backlog – basically, the to-do list for the sprint.

So when we say:

“The team selects an ordered list of user stories to comprise the Sprint Backlog for the next sprint, which will be achievable to satisfy the Sprint Goal...”

We’re really just saying:
👉 “Pick a realistic number of important tasks that, if completed, will help us hit our target for the sprint.”

Not too vague. Not too ambitious. Just achievable and focused.

☀️ Step 3: Daily Standups – Stay in Sync

Now the sprint is underway! But how does everyone stay aligned and avoid working in silos?

That’s where the Daily Standup comes in. Every day – usually in the morning – the team has a quick check-in (about 15 minutes) where each person answers three questions:

1. What did I do yesterday?

2. What am I working on today?

3. Is anything blocking me? (that is, am I stuck?)

Example:

“Yesterday I set up the login API integration. Today I’ll work on the UI validation. I’m blocked on getting access to the staging database — may need help.”

These standups keep the team in sync and surface blockers early so they can be addressed quickly. They’re not about micromanaging or showing off. They’re about visibility and support.

📉 What’s a Sprint Burndown Chart?

You might hear your team mention a “burndown chart.” No, this isn’t about things going down in flames (hopefully).

A Sprint Burndown Chart is a graph that shows how much work is left in the sprint – day by day.

• The y-axis is the amount of work remaining (often measured in story points or tasks)

• The x-axis is the number of days left in the sprint

The line should ideally trend downward as work gets completed – hence “burning down.” If it flattens out or slopes up, that’s a red flag that the team might be stuck, behind schedule, or not updating the board.

Think of it as a visual heartbeat of the sprint. You can learn more via a practical example in this video.

🖥️ Step 4: Sprint Review – Show What You’ve Built

At the end of the sprint, the team holds a Sprint Review (also called a “demo”). This is where you show what was actually built during the sprint.

• The Developers demo working features – live, not just screenshots

• The Product Owner reviews whether the Sprint Goal was achieved

• Stakeholders may ask questions, give feedback, or suggest tweaks

This meeting isn’t just for show – it’s a feedback loop. It helps the team validate that what they built is useful, usable, and meets expectations. If changes are needed, those get added to the backlog for future sprints.

🔍 Step 5: Sprint Retrospective – Look Back to Move Forward

Once the review is done, the team shifts focus from what they built to how they worked together.

Enter the Sprint Retrospective – a meeting to reflect on the process, not the product.

The team discusses:

• ✅ What went well

• ❌ What didn’t go so well

• 🔁 What could be improved next time

This isn’t about pointing fingers. It’s about learning, adapting, and continuously improving how the team collaborates.

The Scrum Master often facilitates this meeting and helps turn feedback into action items for the next sprint. For example:

“We underestimated testing time. Next sprint, let’s budget for QA earlier.”

The best teams take retros seriously. Why? Because even if your code is perfect, your process needs tuning too – and small process changes often lead to big gains.

♻️ Scrum Is a Loop

Here’s the rhythm:

1. Plan the sprint

2. Check in daily

3. Build and demo the product

4. Reflect and improve

Then do it all over again – with slightly better coordination and slightly more trust each time.

It’s not about being fast. It’s about being intentional, consistent, and collaborative.

Example Sprint

Let’s say, for example, that your team does 4-week sprints. (Keep in mind that Sprints can differ by team, nature of product, release cycles, and so on.)

Here’s the rough beat:

Scrum works in loops. Every 2-4 weeks (depending on your cadence and sprint cycle), your team should have working, demo-able software to show for it – even if it’s small.

And no, it’s not about “speed.” It’s about consistency, communication, and collaboration.

Who attends the Ceremonies:

Now lets dive deeper and understand practically how each of these ceremonies work:

Standups: Where You Talk Like a Human, Not a Robot

So how does the team actually stay connected day to day? That’s where standups come in.

Every morning, your team meets briefly – usually on Zoom or in a circle – and you answer 3 questions:

1. What did I work on yesterday?

2. What will I work on today?

3. What’s blocking me? Any impediments?

Example:

"Yesterday I cleaned up the signup validation logic. Today I’m working on the email verification flow. I’m stuck on SendGrid config – might need help setting up credentials."

It’s not about impressing anyone. It’s about keeping everyone in sync. Some days you’ll say, “I spent the whole day debugging a CSS bug that turned out to be a semicolon.” That’s okay.

How does it work?

The Scrum Master gathers everyone in a huddle room, the PO and Dev Team included, and opens the the Standup. They are the facilitator of the ceremony. Everyone gets a chance to answer the 3 questions above (usually about 2-5 minutes each). It’s not a full report – it’s quick. When one person is done, they pass it on to someone else.

This ensures there is team cohesion and transparency.

Here is a video example of a standup.

Sprint Planning

The goal of the planning meeting is to answer the questions “What are we going to work on, and how are we going to do it?” It is critical for the team to have a shared goal and a shared commitment to this goal before beginning this ceremony.

Participants should:

• Measure growth

• Sync with the Scrum Master

• Sync with the Product Owner

Sprint planning happens just before the sprint starts, and usually lasts for an hour or two. In this meeting, the team goes over a collection of user stories and discuss, plan, measure, and prioritize. This is where they decide what is going to be in scope for their upcoming sprint cycle.

The Product Owner will have a prioritized view of things in the backlog. They work with the team on each object or customer experience. Together, as a group they go through and make calculations, deciding to what they can commit.

What’s a User Story and Why Does It Sound Like a Children’s Book?

So you might be wondering: how do you know what to work on? What to build? So much work, so little time? Thats where user stories come in.

In Scrum, teams don’t just write vague tasks like “code the login.” Instead, they write user stories – short, human-centered feature descriptions that describe what the user needs, why they need it, and what success looks like.

Here’s an example:

As a user, I want to be able to reset my password, so I can access my account if I forget it.

User stories are the scaffolding of teamwork. They’re written with empathy, not just efficiency. And each one comes with acceptance criteria – a checklist that clarifies what “done” actually means:

• A “Forgot Password” link is visible

• Clicking it shows a form

• An email gets sent with a reset link

Once a story is agreed upon, developers break it down into tasks, like “build form,” “hook into backend,” or “handle email validation.” It’s collaborative, not prescriptive. And user stories have priority so you know what’s the most important and what’s the least.

A helpful rule of thumb many teams use is the Gherkin-style "Given–When–Then" format:

• Given some initial context

• When an event occurs

• Then a specific outcome should happen

This ensures that everyone – devs, testers, and product owners – shares the same understanding of behavior and expectations.

Here is a great video example thats outlines how to draft effective and powerful user stories.

What Counts as “Done”? Definition of Done and Why It’s Important

Now you might be wondering – how do I know when a task is done and can be closed out?

The Definition of Done is a type of documentation in the form of a team agreement. The Definition of Done identifies the conditions that need to be achieved in order for the product to be considered done (as in potentially shippable).

This is how we know that we "did the thing right". Meaning, we built the correct level of quality into the product. The Definition of Done is not the same as the acceptance criteria, which are written by the product owner to help us know we did the "right thing".

Every team has a Definition of Done – it’s not just “I pushed code.” It could mean:

• Code is written

• Reviewed by a peer

• Merged into main

• Tested on staging

• Possibly deployed

This clarity keeps teams honest and accountable. No “it works on my machine” energy here. The DoD sets a quality bar. It prevents ambiguity, rework, and “it works on my machine” moments. When every card on the board passes the same finish line, teams move faster – and trust each other more.

Everyone should know what done is in a team. Either its Done as per DoD standards or its not.

Here is a beautiful video highlighting the impotence of DoD.

Demos, Retros, and Saying the Hard Things

Once you’ve built the product, then comes demos (showcasing your work) and retros (analysis as a team on what when well and what areas to improve on).

In the retro, everyone’s encouraged to speak up:

• What went well?

• What didn’t?

• What should we try next time?

Example:

“We missed a lot of stories because we didn’t account for testing time. Maybe we buffer next sprint with fewer tasks.”

The goal is not to blame – it’s to improve. Over time, this feedback loop becomes gold. The Scrum Master usually facilitates, collects feedback (via tools like Parabol, Miro, or sticky notes), and helps turn insights into actionable experiments for the next sprint.

Over time, retros become the heartbeat of team evolution.

Here is a video highlighting the importance of a Retro and Sprint Review.

🧠 Why Retrospection Matters More Than You Think

The Sprint Retrospective is more than just another meeting. It’s a mirror for your team – a safe, structured space to pause, reflect, and improve together.

You discuss:

✅ what went well

❌ what did not go well

🔁 what could we do better next time

Great teams don't just deliver great software, they continually deliver better ways of working.

This is why many experienced Scrum practitioners consider the retro to be the most important event in Scrum. Code is deployed once, but process improvements grow exponentially, sprint after sprint.

Tools You Might Encounter

Scrum doesn’t require software, but real-world teams use a variety of tools:

• Jira – Tracks sprints, issues, velocity

• Trello – Simple board, good for small teams

• Slack – Where standups often happen if async

• Notion / Confluence – Docs, retros, notes

• GitHub Projects – Lightweight planning for devs

Don’t worry if you’re not fluent in these yet. They’re tools – you’ll learn them on the job.

If You’re Preparing for a Job, Here’s What You Can Do

• ✍️ Practice writing user stories from your side projects

• 🧪 Run a mini-sprint: Plan your weekend project, set goals, and “review” it at the end

• 🤝 Contribute to an open-source project that uses Scrum or Agile workflows

• 🧾 Write about what you learned – maybe as a tutorial (hint hint)

Final Thoughts

So to recap, Scrum is a simple yet powerful way for teams to work together, stay organized, and deliver results quickly. It runs in short cycles called sprints, where the team plans what to do, checks in daily, shows their progress at the end, and reflects on how to improve.

The four key ceremonies – Sprint Planning, Daily Scrum, Sprint Review, and Sprint Retrospective – help keep everyone aligned and focused. With clear roles and regular feedback, Scrum makes it easier to handle changes, solve problems early, and continuously get better as a team.

But scrum isn’t a magic spell. It’s just a way for humans to build complex things – together – without falling apart.

You don’t need to be a Scrum Master. You don’t need a certification. But if you understand how sprints work, what’s expected of you, and how to show up to meetings with clarity and candor, you’re 10 steps ahead of most.

Scrum helps teams talk, plan, build, and learn. And now? You can too.

If you liked this, please do share. You never know who it might help out.

Until then…keep learning, unlearning, and relearning!!!

We chase productivity without asking a deeper question: Are my actions actually moving me toward who I want to become? Being busy feels good. It's a quick hit of dopamine every time we check something off our to-do list – even if that list has nothing to do with our actual goals.

In my own pursuit of reaching my goals, I began developing a simple framework to help me align my daily actions with the person I wanted to be. This isn't a radically new concept here. It is more like a refined mental model that’s built from things you've probably heard and read before. But it’s designed to fit together in a clear, usable way.

The goal is to help bridge the gap between big-picture intentions and everyday behavior. I call it PATH.

It stands for:

• Purpose – your why

• Aspirations – the vision of who you want to become

• Targets – clear, measurable goals

• Habits – the consistent actions that support those goals

This is the framework I use to stay oriented. Not just to be productive, but to be intentional. I still get off track, but I find my way back a bit quicker.

In this article, you’ll learn how to apply the PATH framework to clarify your direction, set meaningful goals, and build habits that stick.

Table of Contents

1. Busy Doesn't Mean Effective

2. The Power of Frameworks

3. A Framework For Reaching Your Goals

4. Complexity and Difficulty Are Not Synonyms

5. Summary

Busy Doesn't Mean Effective

Being busy can feel like progress. Sometimes it is – you're moving toward your goals, checking boxes, staying active. But other times, it's just noise. A way to avoid sitting still. A way to avoid asking the harder question: Is this making a meaningful difference?

Sometimes, we chase productivity not because we're clear, but because, in fact, we're uncertain. And doing something – anything – feels better than acknowledging we might be lost.

On the other hand, you can have clear goals and develop effective habits. But if someone asked you why you picked those goals, would you have an answer? Why do you want to lose ten pounds? Why do you want to start that company? What are you really aiming for?

Here's a thought experiment: Imagine your funeral. You get to pick one person to give your eulogy – and they can only say one sentence about you. What do you hope they'll say?

This is a personal question. And I know my answer very clearly. Do you know yours?

The Power of Frameworks

You do not rise to the level of your goals. You fall to the level of your systems.

— James Clear

In programming, a framework is predefined code that helps developers build software more efficiently and effectively. It abstracts away the implementation details of common problems – things you could handle yourself, but probably don't need to. The tradeoff? You give up some flexibility in exchange for speed. In other words, frameworks help you solve your problem faster by deciding a few things for you.

Developers lean on frameworks like React or .NET because they help us focus on solving meaningful problems, rather than wrestling with boilerplate code. PATH works the same way: it abstracts the structure so you can spend more time executing on what matters.

When it comes to setting goals, it's no different. It's easy to get lost in these implementation details and end up overcomplicating the process. We want the perfect strategy or the ideal plan. But in reality, progress almost always beats perfection. Initially, we don't need the most elegant system – we need one that we can follow.

That's where frameworks shine. They reduce friction and help you stop tinkering with the how and start taking action on the what. They free up mental energy, allowing you to focus on actually solving the problem.

This isn't new. Every great tool – whether it's a budgeting app, a productivity system, or a JavaScript library – obscures just enough complexity to help you move towards a solution faster.

A Framework For Reaching Your Goals

PATH is a framework I've used for years to align my actions with my desired future self. Most goal-setting systems start with habits or outcomes, but PATH begins a bit further back: your purpose.

P is for Purpose

Purpose is the core of who you are and what matters most. It is your mission statement, no more than a sentence or two. It should be you. A strong purpose will help you get back on track when you veer off course.

A is for Aspirations

Once you've decided on your purpose, the next step is to dream a little. This is the fun part.

Where do you want to be in the next 5 to 10 years? Try to picture a typical day of your ideal future – not necessarily what you own, but what you experience and do.

• Where do you live?

• What time do you wake up?

• What do you do during the day?

• Who are you with?

Here is an example:

I live by a beautiful lake in the mountains. I get up around 7 am, go for a long run, and then eat a healthy breakfast. I spend my day writing. Evenings are slow, spent laughing on the porch with friends and family.

Now, let's break that down into aspirations – broad themes that define the kind of life you're building. From that vision, here are three I see:

• Be in good shape

• Be a writer

• Spend quality time with friends and family

These are your aspirations – the "A" in PATH. And they're not meant to be specific or time-bound. Think of them as a compass, not a destination. Their job is to give you something to aim at over and over again.

T is for Targets

Targets are the specific goals we aim to achieve.

Each aspiration should have one or more targets – clear, time-bound goals that move you in the direction of your aspiration.

These targets should follow the SMART framework:

• Specific

• Measurable

• Attainable

• Realistic

• Time-bound

For example, if you aspire to become a software developer, a target might be:

Contribute one fix or update to an open-source project by the end of the month.

If aspirations are our compass, targets are the destination. They let you measure progress and know when you've arrived.

H is for Habits

Habits are where the rubber meets the road.

Every target should have one or more supporting habits – things you do consistently that move you towards your goal. While they will generally be daily or weekly routines, one-off tasks are also acceptable. The idea is these are things that move the needle.

For example, if your target is to run a 5k event, a habit might be:

Run 3 miles every other day.

Or, if you're just starting, you may want to create a one-off task such as:

Map out a running route.

Again, these habits (or tasks) are needle-movers. Following them – actually following them – should almost guarantee that you reach your targets.

When it comes to building a habit, the key is to start small, sometimes really small. In the beginning, the goal isn’t performance, it’s momentum. And while momentum can be hard to start, once it’s moving, it’s even harder to stop.

If you’re trying to build a writing habit, begin with two sentences. If you want to exercise more, start by putting on your workout clothes. Or just drive to the gym. The point is to make starting frictionless.

Consistency also depends on cues. Every habit needs a reliable trigger – something that prompts you to take action. It might be a specific time of day, walking in the door after work, or finishing your morning coffee. Over time, that cue becomes automatic, and so does the habit.

Complexity and Difficulty Are Not Synonyms

There's a moment in the boxing film Bleed for This where the main character is asked, "What's the biggest lie you've ever been told?" He answers:

"It's not that simple."

The interviewer tries to clarify – as if she believes the main character doesn't understand the question – but he cuts her off and essentially says:

"No, that's the lie. It is that simple."

That line stuck with me, because we often treat life like it requires a perfect plan before we can begin. However, sometimes the hardest part is simply deciding.

Don't confuse something hard with something that's complex. In my experience, the most meaningful things in life are often simple yet challenging.

Knowing what to do isn't the challenge. It's doing it – over and over again, especially when it's boring, inconvenient, or the outcome is uncertain. That's why clarity matters, and frameworks can help.

There's the person who spends their entire life looking for an elevator. And then there's the person who starts climbing the stairs.

Figure out who you want to be, and filter your goals and actions through that lens.

I'd bet almost anyone reading this could name a few things that would take less than an hour a day that would completely change their life over time. The difference – the only difference – is that the person who gets clear on what they want and then actually does those things every day...gets there.

At the end of the day, the goal isn't to be productive. It's to be intentional. To align your daily actions with your goals and ensure those goals are pushing you toward the person you want to become. That's the idea behind PATH – a framework for being intentional.

Summary

If you remember nothing else, here’s the heart of PATH:

• Purpose – Define your why. A short, personal mission statement that keeps you grounded.

• Aspirations – Paint a picture of who you want to become. Think 5–10 years out, focused on experience, not possessions.

• Targets – Turn aspirations into SMART goals with clear deadlines. These give your vision structure.

• Habits – Identify consistent, meaningful actions that drive progress toward your targets – daily, weekly, or even one-off tasks.

I’ve created a free Notion template to help you get started with the PATH framework.
→ PATH Goal Tracker Essentials

There’s also an upgraded version available for those who want habit tracking, progress calculations, and more.
→ PATH Goal Tracker Plus

Found this helpful? I write about practical automation, productivity systems, and building smarter workflows — without the jargon. Visit me at brandonwoz.com.

Maybe you’ve said it yourself.

In the rush to launch a feature, meet a deadline, or impress a client, you take a shortcut. The code works – for now. The design passes – for now.

But over time, these choices pile up. They slow you down. They make every change harder. That’s technical debt.

Technical debt is a quiet, creeping cost. It doesn’t show up in metrics like churn or conversion rate. But it eats away at your product’s quality, your team’s velocity, and your ability to innovate.

You don’t notice it right away. Then, suddenly, everything feels slower. Nothing is simple anymore.

One bug fix breaks two new things. Engineers groan when they touch certain parts of the code. That’s when you realize you’re in debt.

Let’s talk about what technical debt really is, how it forms, and how you can deal with it before it kills your product.

What Is Technical Debt?

Think of technical debt like financial debt. When you borrow money, you get something now – at the cost of interest later.

In software, it’s the same. You make a quick decision to save time now, knowing it might cost you more effort down the line.

There’s nothing inherently wrong with that. Sometimes, taking on debt is smart. You might need to ship fast to test an idea or respond to the market.

But if you keep borrowing and never repay, the interest builds. And technical debt doesn’t just grow – it compounds. The longer you leave it, the worse it gets.

You don’t just end up paying more later. You slow down your whole team.

Every new feature takes longer. Bugs multiply. Morale drops. And eventually, your product feels fragile. That’s when the real damage begins.

Types of Technical Debt

Not all debt is the same. Some is like a short-term loan – you know you’re taking it and why. Other debt is like a bad mortgage – no one even knows it’s there until things break.

Here are the most common types:

• Intentional debt — You cut corners to hit a deadline but log it and plan to fix it. This can be healthy if managed well.

• Unintentional debt — You didn’t realise the shortcut was harmful. Often happens with new tech or unclear requirements.

• Environmental debt — Your tools, libraries, or frameworks get outdated. Even if your code is clean, it sits on crumbling infrastructure.

• Process debt — The way you build software becomes inefficient. Poor handoffs, unclear documentation, or weak testing pipelines all contribute.

Recognising which type you’re dealing with helps you prioritise. Not all debt needs immediate repayment. But all of it needs attention.

How Technical Debt Happens

As you can probably imagine, technical debt shows up in many ways.

Sometimes it’s deliberate. You make a tradeoff. You know it’s a shortcut, and you plan to clean it up later. That’s manageable – if you actually clean it up.

But most technical debt isn’t planned. It sneaks in through decisions that feel small in the moment. A rushed feature. A new hire not trained on the codebase. A spec that changes mid-sprint. Over time, these small cracks become deep fractures.

Here’s a simple example:

// Temporary workaround for product discounts
function applyDiscount(price, productType) {
  if (productType === 'electronics') {
    return price * 0.9; // 10% off
  } else if (productType === 'clothing') {
    return price * 0.8; // 20% off
  } else if (productType === 'books') {
    return price * 0.95; // 5% off
  } else {
    return price;
  }
}

This started as a quick fix. But over time, new product types get added with more exceptions.

Soon, you will have twenty if-else branches. It’s fragile. Every change risks breaking something. That’s technical debt.

The worst part? You might not even notice until a year later, when a bug in that logic takes hours to trace. You wonder, “How did this get so messy?” The answer: one shortcut at a time.

A better long-term approach in the above example would be a configuration-driven system or a discount rules engine.

// Config-driven discount logic
const discountRates = {
  electronics: 0.10,
  clothing: 0.20,
  books: 0.05
};

function applyDiscount(price, productType) {
  const discount = discountRates[productType] || 0;
  return price * (1 - discount);
}

Why Technical Debt Can Be Dangerous

Technical debt slows you down. That’s its most visible cost.

A feature that should take a day now takes a week. Simple changes break unrelated things. Your team spends more time fixing than building.

But the real danger goes deeper. Technical debt makes you afraid to touch your code.

Engineers stop refactoring because “it’s too risky.” You start saying no to new ideas because the system can’t handle them. The product becomes rigid. You stop innovating.

It also hurts your team. Developers don’t like working in messy codebases. It leads to burnout. New hires struggle to onboard.

Your best engineers spend their time firefighting instead of creating. Eventually, people leave. And your debt remains.

How to Manage Technical Debt

You can’t eliminate all technical debt. But you can manage it.

First, treat it like real debt. Track it. Prioritize it. Make regular payments.

Start by writing it down. Every time someone takes a shortcut, log it. You don’t need a fancy tool – a shared doc or Jira tag works fine. Just make it visible.

Next, build time into your workflow to pay it off. Use 10–20% of each sprint to refactor or improve the codebase. Don’t wait for a rewrite. Small, steady work adds up.

Code reviews help too. Encourage your team to ask: “Is this a shortcut?” If yes, make a conscious choice. Leave a clear comment. Note the tradeoff. Now it’s not a hidden cost – it’s a known one.

And when you do pay off debt, celebrate it. Make it part of your culture. The same way you’d celebrate shipping a feature, acknowledge when your team makes the codebase better. That builds pride and ownership.

Knowing When to Refactor

You can’t fix all the debt at once. So how do you choose?

Look for signs of pain. If a file breaks every sprint, fix it. If one part of the system takes days to test, improve it. If new hires always get stuck in one module, clean it up.

Focus on the code you touch often. There’s no point polishing a dead feature. But if something is part of your core flow, invest in it.

Also, listen to your team. Engineers know where the pain lives. If someone says, “This part scares me,” take that seriously. Fear in the codebase is a red flag.

When Debt Becomes Fatal

Sometimes, the debt gets so bad that small fixes won’t save you. The system collapses under its own weight. Everything feels slow. Nothing is safe to change. That’s when teams start talking about rewrites.

But rewrites are risky. They take time. They often miss hidden business logic. And they can carry old debt into new code if not done carefully.

If you must rewrite, do it incrementally. Replace modules one at a time. Add tests. Migrate data with care.

And don’t forget why the old system failed. If you don’t fix the culture, the new system will rot too.

Final Thoughts

Technical debt isn’t evil. It’s part of building software. But like financial debt, it needs discipline. You can’t just ignore it and hope it goes away.

Great products aren’t just well-designed. They’re well-maintained. The teams behind them care about quality — not just in what users see, but in what engineers live with every day.

So the next time you say, “We’ll fix it later,” ask yourself: will you? Or are you just borrowing against the future?

Hope you enjoyed this article. Join my newsletter for similar articles and connect with me on Linkedin.

The Continuous Integration (CI) part of CI/CD means that developers can always integrate or merge their changes into the shared repository without breaking anything. Continuous Delivery, on the other hand, means that the code changes are automatically prepared for release after testing and validation.

CI/CD primarily involves various stages like building, testing, staging and deployment.

• Build phase: This is where the code and its dependencies are compiled into a single executable. This is the first phase of Continuous Integration, and is triggered by an event like pushing code to the repository.

• Test phase: Here, the built artifacts are tested to be sure that the code runs as expected.

• Staging: Here, the application is run in a production-like environment so as to be sure it is production ready.

• Deployment: Here, the application is automatically deployed to the end-users.

In this article, I’m going to explain how GitHub Actions works. I’ll also talk about basic GitHub Actions concepts, and then we’ll use it to build an example CI/CD pipeline.

What is GitHub Actions?

GitHub Actions is a service or feature of the GitHub platform that lets developers create their own CI/CD workflows directly on GitHub. It runs jobs on containers hosted by GitHub. The tasks are executed as defined in a YAML file called a workflow. This workflow file has to live on the .github/workflows folder on the repository for it to work.

Basic GitHub Actions Concepts

GitHub Actions consists of events, jobs, tasks, runners, workflows, and various other features. Here is a brief explanation of the main concepts:

Events: An event is basically something that happened. With GitHub, an event can be a push (when you push your code to the repository), a pull request, or even a cron job. These events trigger the CI/CD process.

Tasks: When you use CI/CD, you want to be able to trigger an activity that should be done automatically. That activity is known as a task or step in GitHub. It could be building your code or testing it or deploying it.

Each of those tasks has to be defined by commands. A GitHub Actions task usually consists of the name, and the instructions on what to do in the form of a command which starts with - run: or an Action which starts with - uses:.

steps:
  - name: Checkout code
    uses: actions/checkout@v3

  - name: Set up Node.js
    uses: actions/setup-node@v3
    with:
      node-version: 16

  - name: Install dependencies
    run: npm install

  - name: Run tests
    run: npm test

  - name: Build project
    run: npm run build

  - name: Deploy
    run: echo "Deploy step goes here"

Runner: A GitHub runner is a server that runs your tasks. It executes what is defined in your GitHub workflow. You can use your own runners or you can use the GitHub runners.

Job: A job is a collection of steps that are being executed on the same runner. Jobs are defined in a file called the workflow.

Workflow: The GitHub workflow is a series of jobs defined in a YAML file, that are triggered upon an event. The events do not trigger individual tasks. They can only trigger workflows. Then the tasks in the jobs of the workflow are executed.

Contexts: These provide a way to access information about workflows, jobs, and environments in GitHub. They are accessed with the expression $${{ <context> }}. Examples include github, env, vars, and secrets. The github context is used to access information about the workflow. For example:

$${{github.repository}} # should tell the name of the repository

$${{github.actor}}  # should tell the username of user that initially triggered the workflow

Secrets: This is used to store and access sensitive information that’s used by, and is available to, the workflow. Secrets are redacted when printed to the log. An example is $${{secrets.GITHUB_TOKEN}}.

How to Build a Simple CI/CD Pipeline

Here, we’re going to build an example workflow to deploy a simple HTML and CSS website to GitHub Pages. Follow the steps below:

1. Go to the sample code in my repository and fork it from here.

2. Go to the settings tab in the GitHub repository:

3. Go to the Pages settings:

   

4. Set the deployment source to the main branch:

   

5. Go to the General Actions settings and scroll down to the bottom:

6. 

   At the bottom, set the Workflow permissions to read and write:

7. In the GitHub repository, you can clone it to your PC or press the fullstop (.) on your keyboard to open GitHub Codespaces, the online version of VS Code.

8. Go to the sidebar and click on create a new file:

   

9. Create a workflows folder and file. You can call it deploy.yaml.

   

10. Copy this code into the file:

name: Deploy Static HTML and CSS to GitHub Pages

# Trigger the workflow on push to the main branch

on:
  push:
    branches:
      - main
# Define what operating system the job should run on
jobs:
  deploy:
    runs-on: ubuntu-latest
    permissions:
      contents: write

    steps:
    # Step 1: Checkout the repository
    - name: Checkout Code
      uses: actions/checkout@v4

    # Step 2: Check the files that have been checked out
    - name: Display files
      run: ls

    # Step 3: Deploy to GitHub Pages
    - name: Deploy
      uses: peaceiris/actions-gh-pages@v4
      with:
        github_token: ${{ secrets.GITHUB_TOKEN }}
        publish_dir: ./ # The HTML and CSS files lie in the root directory, hence that should be the publish directory

11. Commit the code. You should see the job running when you go back to the repo:

When you’re done, go back to the home page of the repository and click on the Deployments section. There, you will see the GitHub Pages link to the deployment:

When you’re done, your repository should look like this.

Conclusion

In this article, you learned about how the CI/CD process works. We also covered the basic concepts of GitHub Actions. Finally, we created an example CI/CD pipeline with GitHub Actions. If you enjoyed this article, share it with others. You can also reach me on LinkedIn or X.

One of the most promising free AI coding assistants is DeepSeek. It’s been hailed as a game changer and has a reasoning model on par with or even better than OpenAI o1. It offers advanced code suggestions and supports multiple programming languages.

But here’s the problem—do you know what happens to your code after you enter it? Many free AI models operate as black boxes, with little transparency about how they handle user data. This raises serious concerns about code privacy, intellectual property security, and compliance with industry regulations.

For developers working on proprietary software or handling sensitive data, these risks aren’t just theoretical—they can lead to source code leaks, compliance violations, or even unauthorized AI training on your data.

That’s why third-party AI coding assistants are becoming the preferred choice. Unlike free tools, these alternatives offer better data protection, stronger security measures, and compliance-friendly environments without sacrificing performance.

In this article, we’ll break down how free AI coding assistants like DeepSeek pose security risks and why third-party alternatives provide a safer, more reliable solution for developers at all levels. I’ll also share with you my personal choices and discuss their features and strengths.

Benefits of DeepSeek

AI coding assistants have improved a lot recently, and DeepSeek-R1 is one of the most advanced free tools available. It goes beyond simple autocomplete, offering intelligent code suggestions, multi-language support, and AI-powered debugging—all for free.

Its model leverages technologies like Retrieval-Augmented Generation (RAG) to achieve context-awareness and it uses reinforcement learning to approach tasks with reasoning rather than simply predicting the most likely outcome and shows the user it’s chain of thought and process by which it came to a conclusion or carried out the task given to it.

What Makes DeepSeek Stand Out?

• DeepSeek understands context and intent, generating full functions instead of just completing words or lines. It also incorporates reinforcement learning to give better and more accurate responses, much like human reasoning. This makes the code it outputs more accurate.

• Deepseek has ‘chain of thought” capabilities and it shows users it’s reasoning process while completing tasks or user inputs.

• DeepSeek has support for multiple languages, and works seamlessly across Python, JavaScript, Go, Rust, and more.

• DeepSeek is also very fast, giving you near-instant recommendations and helping you write code faster without breaking your flow.

• DeepSeek is also a helpful debugger, as it not only suggests code but can also identify errors and recommend fixes. It can achieve this because the model is context-aware.

• Finally, it’s free. Unlike some AI tools locked behind paywalls, DeepSeek provides all these features at no cost.

With these capabilities, it’s no surprise that DeepSeek is gaining traction among developers looking for a free AI-powered coding assistant reported as the Most downloaded app within Apple’s Top Free App category. But does free always mean safe?

The Security Risks of Free AI Models Like DeepSeek

For all its benefits, DeepSeek—like most free AI coding assistants—comes with security risks that can’t be ignored.

First of all, do you know what happens to your code when you input it? DeepSeek doesn’t clearly disclose whether it stores or analyzes user input, raising concerns about data privacy and proprietary code exposure.

During a call with members of her subscription training, Heather Murray, an AI consultant for major corporations and the U.K. government who serves on the ISO committee for AI security, expressed concerns about DeepSeek’s policies regarding user data:

“It keeps your data as long as it wants to, and even after users leave the app, it doesn’t delete their data. It’s going to hang on to that. That is a massive worry. All of that data is then transmitted and stored on servers in China. So that removes user data from under U.S., U.K. or European law — moving it under Chinese law, which is very, very different.”

There are also potential intellectual property risks to think about. If DeepSeek retains input data, could fragments of your code appear in suggestions to other users? This is a real risk with AI models trained on user data. This means that any proprietary code you submit could become a suggestion for competitors using the same platform.

DeepSeek also hasn’t implemented any enterprise security standards. Unlike paid enterprise-grade AI solutions, DeepSeek does not provide guarantees of compliance with security frameworks like GDPR, SOC 2, or HIPAA.

Finally, there’s no guaranteed data isolation. Enterprise AI solutions often provide private model deployments or air-gapped environments, while free AI tools rely on centralized cloud processing, increasing exposure risks. This means your code is sent to external servers, increasing the risk of leaks or unauthorized access.

These risks don’t mean DeepSeek isn’t useful—but they do mean developers working on proprietary projects, enterprise applications, or sensitive data should think twice before relying on it alone.

Secure Alternatives to Free AI Coding Assistants

If you rely on free AI coding assistants, you’ll need to balance performance, usability, and security. While free models like DeepSeek offer powerful code suggestions, they lack key security features required for professional and enterprise use.

Third-party AI tools provide a safer alternative, ensuring data privacy, enterprise compliance, and secure code processing.

So you might wonder: how do these third party apps achieve this higher level of security? Well, they do it by hosting the service on their local/personal servers which are under US and EU regulations and data protection laws. This is unlike the free DeepSeek API, which may route queries through shared infrastructure, which comes with unspecified backdoor access.

Here are two confirmed DeepSeek-powered AI assistants that address the security limitations of free models:

1. QodoGen

QodoGen has a secure DeepSeek-powered AI assistant. It’s built for security-conscious developers and enterprises who want the advantages of DeepSeek without exposing sensitive code.

Some of its features are:

• Built-in security: Unlike the free DeepSeek model, QodoGen does not store, log, or use code for training.

• Enterprise-grade protection: It’s designed to meet data privacy regulations like GDPR, SOC 2, and HIPAA.

• Seamless IDE integration: QodoGen provides the same intuitive, real-time assistance as DeepSeek but with enhanced security controls. It’s available on your favorite IDEs like VSCode and JetBrains IDE.

• Optional Data Sharing: Allows organizations and developers to fine-tune security settings and host the model on-premises or in a private cloud. It also provides users with the choice to Opt Out of data sharing with it’s servers all together( Go to the extension's settings and check the box Opt out of sharing my data with Qodo.)

• Custom AI model options: It also has other AI models you can choose from to suit your personal or organization’s needs like OpenAI o1, GPT-4, Claude Sonnet 3.5, Gemini 2.0 flash and so on.

• Guaranteed data isolation: QodoGen provides private model deployments / air-gapped environments which prevent unauthorized data collection.

Example of Deepseek-R1 showing chain of thought on QodoGen

How to get QodoGen

To get QodoGen set up, visit its page on Visual Studio Marketplace to install it.

Alternatively, follow these steps to install the plugin from within VSCode:

1. In VSCode, open the Extensions menu. You can do this by either:

   • Clicking the Extensions icon in the Activity Bar on the left side.

   • Using the keyboard shortcut: Cmd+Shift+X for macOS. Ctrl+Shift+X for Windows and Linux.

2. Type Qodo Gen in the search bar.

3. Click the Install button.

4. Sign Up with your email.

To login to the Teams plan, after you have received an invitation, login using the email to which the invitation was sent. Team plans start at $15/month, while Enterprise solutions start at $45/month.

QodoGen also has a free plan for individual developers. You can check out their pricing here.

2. Perplexity AI

Perplexity AI integrates DeepSeek-R1 while implementing security safeguards to minimize data risks. It originally served as a search engine for researchers, so it comes with cited sources for the output it generates. This means you can check, confirm, and further research any output it generates.

Some of its key features are:

• Data hosting security: User queries are processed in US/EU data centers, reducing risks associated with external data exposure.

• Privacy-focused AI responses: Unlike free DeepSeek, Perplexity AI’s infrastructure prevents unauthorized data collection.

• Available via web platform: Developers can access AI-assisted coding with DeepSeek’s capabilities without having to download the any application.

• Gives you sources along with the output it generates, so you can be rest assured that the output is accurate (which you can confirm for yourself).

• It has a free plan for individual developers, as well as a Teams subscription (starting at $20/month) and Enterprise subscription (with customizable plans). You can check out their pricing here.

Example of Deepseek-R1 showing chain of thought on Perplexcity AI

The above screenshot shows how it produced the output step by step. You can also see the option to read further with the dropdown buttons with sources for confirmation and resources for further study.

How to Choose the Right AI Coding Assistant

With the growing number of AI coding assistants available, selecting the right one comes down to security, data privacy, and usability. Whether you’re an individual developer or part of an enterprise team, your AI assistant should offer:

• Strong security measures

• Enterprise-ready compliance

• High-quality AI models

• Seamless accessibility

Both QodoGen and Perplexity AI have demonstrated a commitment to these principles. By integrating DeepSeek-R1, they provide cutting-edge AI assistance while maintaining security and ease of access for developers.

My Recommendation: QodoGen for Developers, Perplexity for Quick Access

For developers, teams, and enterprises, QodoGen is the best choice. It’s designed specifically for developers, integrating directly into popular IDEs like VS Code and JetBrains IDE. This ensures a smooth, secure, and efficient coding experience without data privacy concerns.

QodoGen delivers the power of DeepSeek-R1 and other top AI models while keeping your code protected within your development environment.

For individuals looking for an easy, web-based solution without installing an extension, Perplexity AI offers a good alternative. Without the need for installations, it provides AI-assisted coding in a browser, making it an accessible option if you prefer quick and hassle-free access to DeepSeek-R1 and don’t need deep IDE integration.

Conclusion

AI coding assistants have become essential tools for developers, but not all solutions prioritize security and data privacy. While free models like DeepSeek offer impressive capabilities, they come with potential risks that developers and enterprises cannot afford to overlook.

Third-party AI coding assistants provide a secure and reliable alternative, ensuring that code remains private while still delivering state-of-the-art AI performance. Among them, QodoGen and Perplexity AI stand out by integrating DeepSeek-R1 into their platforms before others while maintaining a strong commitment to security and accessibility.

For developers, teams, and enterprises, QodoGen is the ideal choice, offering a seamless IDE experience with enterprise-grade security. Meanwhile, if you prefer quick, web-based access, Perplexity AI provides a hassle-free way to leverage DeepSeek-R1 without installation.

It’s not just about learning a programming language and typing out code to build software. There’s a lot more to it. And one of the most confusing (and often frustrating) topics for developers is clean code.

So, what is clean code?

Simply put, it’s about writing code that’s so clear and well-organized that neither you nor anyone else will get frustrated trying to understand it six months later.

Think of clean code as the programming equivalent of great design — it’s functional, beautiful, and easy to work with.

And today, I won’t spend a lot of time explaining why clean code is important — you probably already know that. Instead, I’ll get straight to the point and share seven powerful hacks to help you write cleaner, better code.

Table of Contents

• 1. Write Code Like You’re Explaining it to a 5-Year Old

• 2. Use AI Tools (or an AI Code Reviewer)

• 3. Get Rid of Unnecessary Comments

• 4. Follow the DRY Principle

• 5. Fix Your Code Formatting & Follow a Consistent Style

• 6. Don’t Let Your Functions Do Too Much

• 7. Organize Your Files and Folders Properly

• Wrapping Up

1. Write Code Like You’re Explaining it to a 5-Year Old

Let me be honest — if you are writing exceedingly clever code that your teammates or someone else can’t easily read, it won’t be helpful to anyone.

You need to write code so simple that anyone, including someone who just opened the file for the first time, can easily go through it.

For example, if your variable names look like this:

let x = y + z;

This isn’t helpful. No one will know what x, y, and z mean — not even you, three weeks later.

Variables should describe what they hold. Think of them as self-documenting comments. Here’s a better example:

let totalPrice = productPrice + shippingCost;

This simple best practice can be applied even when writing functions, comments, and more.

Here’s an example of hard to understand code:

function calc(itm) {
 let t = 0;
 for (let i = 0; i < itm.length; i++) {
 t += itm[i].p;
 }
 return t;
}

You see, it doesn’t give you a proper idea about the function other than the logic.

Instead, try to write it like this:

function calculateTotalPrice(cartItems) {
    let totalPrice = 0;
    for (let i = 0; i < cartItems.length; i++) {
        totalPrice += cartItems[i].price;
    }
    return totalPrice;
}

Now it’s clear just from looking at the code what’s going on.

2. Use AI Tools (or an AI Code Reviewer)

AI is evolving quickly and is being used in almost every industry.

Well, as a developer, you can use AI to help you write clean and readable code — all thanks to AI tools like ChatGPT, Claude, and GitHub Copilot.

For starters, you can copy and paste your code into an LLM and ask it to review your code.

Here’s an example of a request I made to ChatGPT:

And here’s what ChatGPT recommended:

It even provided me with an improved version of the code. Here it is as follows:

Along with that, you can also use AI-powered code reviewers like CodeRabbit AI, which integrates with your pull requests to offer automated code reviews, walkthroughs, and more.

In simple terms, when you install CodeRabbit AI, add it to your pull request, and then create a pull request, CodeRabbit AI provides you with summaries, code reviews, walkthroughs, and more.

Here’s an example from an open-source repository “minefield” of a summary generated by CodeRabbit AI:

In the above examples, CodeRabbit AI simply goes through the code and provides a great summary highlighting the new features, bug fixes, and unit tests added via a pull request.

If you want to learn more, here’s a quickstart guide that provides more info on how to get started and use CodeRabbit AI.

Note that, AI tools can be a great help in improving your code, but they should never replace your own thinking.

When AI suggests changes, always ask yourself: Does this actually make sense?

After all, AI isn’t perfect—it can generate incorrect code. It might also miss important details that only a human can fully understand.

So instead of blindly accepting AI’s suggestions, take a moment to understand why they were made.

Remember, the goal is to use AI to speed up your workflow, catch errors, and more—while keeping full control over your code.

3. Get Rid of Unnecessary Comments

Writing good code comments can help others understand why your code is doing what it’s doing.

But I see developers writing too many comments, even where there is no need.

I believe that, whenever possible, good code should document itself.

Here’s an example of a not so helpful comment:

// Adding 10 to the result 
total = total + 10;

You see, here the comment doesn’t make sense, and it doesn’t really add anything to the code (or our understanding of it).

It’s a better practice to write comments only if they’re important in helping a reviewer understand why you did something in particular or if there’s some ambiguity that needs explaining.

Here’s an example:

// Adding 10 because the client requires a 10% buffer for calculations 
total = total + 10;

Now you can see that here the comment gives a clear idea about why the programmer added 10 to the total.

4. Follow the DRY Principle

I’ve seen a lot of programmers repeating the same logic or adding the same functionality in different files.

Well, you don’t need to repeat the same code everywhere because it makes the process much more complex. Keep your code DRY (Don’t Repeat Yourself).

Instead, abstract that logic into a single reusable function.

For example, instead of writing the same logic in different files:

if (user.age > 18 && user.age < 65) { 
 // Do something 
}

if (user.age > 18 && user.age < 65) { 
 // Do something else 
}

You can create a reusable function so that you can use the logic everywhere, as shown below:

function isWorkingAge(age) { 
 return age > 18 && age < 65; 
}

if (isWorkingAge(user.age)) { 
 // Do something 
}

In short — write once, and use everywhere.

5. Fix Your Code Formatting & Follow a Consistent Style

This is another simple hack, but many devs don’t even think about it.

First of all, you need to format your code with proper indentation.

You can just install a VS Code extension/linters like Prettier, ESLint, or Flake8, depending on the programming language you use. Configure a few settings, and you’re good to go.

These linters can help you write better code by finding mistakes, helping you follow coding rules, and keeping your code consistent. They can also catch errors, make your code easier to read, and save time on fixing bugs and reviews.

But fixing your formatting doesn’t just mean it’s clean code – it’s way more than that.

Beyond formatting, you should stick to a consistent style guide for things like function names or variable names.

For example, here’s some code that has an inconsistent style:

let total_price;  
let UserData;  
function getuser() {}

But some of you may ask, why is the code inconsistent?

Well, it uses several different naming conventions – like total_price uses snake_case, UserData uses PascalCase, and getuser() is in lowercase instead of camelCase.

This makes your code harder to read and more confusing. Instead, you can follow a consistent style. Here’s how:

let userData; 
let totalPrice; 
function getUser() {}

And just to let you know, JavaScript typically follows camelCase for variables and functions, so names like getUser(), userData, and totalPrice would be more consistent.

No matter whether you’re working in a team or solo, sticking to one style is a good idea. It makes the code clean, and the reviewer can easily go through it.

6. Don’t Let Your Functions Do Too Much

As a programmer, I know that sometimes you need to write complex logic inside a function.

But most often, programmers include too much logic in a single function, causing it to do more than one thing at a time. These functions become too complex, making them hard to read or understand.

It’s better to create multiple smaller functions, with each function handling a single responsibility.

Here’s an example of a slightly too complex function:

function calculateCart(items) {
 let total = 0;
 for (let i = 0; i < items.length; i++) {
 total += items[i].price * items[i].quantity;
 }
 return total > 100 ? total * 0.9 : total;
}

You see, this single function does too much—it applies discounts if applicable, and calculates the total price based on quantity, making it hard to reuse for specific use cases.

A better way is to split it into three functions:

• One to apply the discount (if applicable).

• One to calculate the total price based on quantity.

• One to get the total and apply the discount if needed.

This makes the code cleaner and easier to manage. Here’s an improved version:

function calculateCart(items) {
 const total = getCartTotal(items);
 return applyDiscount(total);
}

function getCartTotal(items) {
 return items.reduce((sum, item) => sum + item.price * item.quantity, 0);
}

function applyDiscount(total) {
 return total > 100 ? total * 0.9 : total;
}

You see, instead of writing everything in one long block, the logic is broken into smaller, clearer functions.

And that’s what makes it easier for you (and everyone else) to understand.

7. Organize Your Files and Folders Properly

Now comes the most important part.

When you’re working on a big project, it makes no sense to dump all your code into one single folder with a bunch of random files. It’s become a nightmare for anyone trying to review the code or find a specific file.

Think about it — going through 50 files just to fix a bug. Nobody wants that.

Instead, try organizing your project into multiple folders based on pages or features.

And don’t stop there — break large files into smaller, specific modules based on functionality. This way, everything is neat, easy to find, and makes sense at first glance.

Here’s a bad example of a project structure:

project-folder/  
│  
├── index.html  
├── app.js  
├── helpers.js  
├── data.js  
├── user.js  
├── product.js

It’s messy, right? Now, here’s how you can improve it:

project-folder/  
│  
├── pages/  
│   ├── home/  
│   │   ├── HomePage.js  
│   │   ├── HomePage.css  
│   │   └── HomePage.test.js  
│   ├── user/  
│   │   ├── UserPage.js  
│   │   ├── UserPage.css  
│   │   └── UserPage.test.js  
│   └── product/  
│       ├── ProductPage.js  
│       ├── ProductPage.css  
│       └── ProductPage.test.js  
├── components/  
│   ├── Header.js  
│   ├── Footer.js  
│   └── Button.js  
├── utils/  
│   └── api.js  
└── index.js

See how simple this is?

You have separate folders for pages, components, and utilities. Inside each folder, files are organized by purpose and given clear names.

For example, if you need something for the product page, you’ll know exactly where to find it.

Wrapping Up

In this article, you learned the basics you need to get started writing clean, efficient, and maintainable code.

We discussed how to write clean code, use AI tools, apply proper code formatting techniques, structure functions effectively, and follow other best practices.

If you apply these tips consistently, you’ll significantly improve your coding skills and write cleaner code.

I hope you liked it.

You can connect with me on Substack, and Twitter.

Also, if you're interested in learning more about AI, you can subscribe to my newsletter, AI Made Simple, where I dive deeper into practical AI strategies for everyday people.

The 8 Ivy League schools - Harvard, Yale, Princeton, Columbia, Cornell, Dartmouth, Brown, and the University of Pennsylvania - are among the most prestigious universities in the world. In 2025, all 8 Ivy League schools are ranked in the top-20 of the U.S. News & World Report national university ranking. While these institutions are highly selective and difficult to get into, they offer many of their courses online for free.

Using Class Central's database, I've compiled these courses for you. In total, Ivy League schools currently offer over 1,850 courses that have attracted 60 million enrollments and 1.7 million bookmarks. Looking at the data:

• Brown University (81 courses)

• Columbia University (56 courses)

• Cornell University (14 courses)

• Dartmouth College (231 courses)

• Harvard University (357 courses)

• Wharton School of the University of Pennsylvania (3 courses)

• University of Pennsylvania (21 courses)

• Princeton University (8 courses)

• Yale University (1096 courses)

The Class Central database has over 250,000 online courses.

For those interested in staying updated on new Ivy League course offerings, you can "Follow" our dedicated collection on Class Central.

Note that figuring out how to audit a course for free on platforms such as Coursera can be a bit confusing. So my colleague Pat and I have written a dedicated guide: How to Sign up for Coursera Courses for Free.

In this guide, Harvard's CS50 courses clearly stands out - the first CS50 course has attracted over 6 million learners on edX alone. For that reason, we created a dedicated guide: Harvard CS50 Guide: How to Pick the Right Course (with Free Certificate) where my colleague Manoel reviews the complete lineup of 14 courses, including 10 that offer free certificates of completion.

Also, recently we published a free developer certificates article with thousand of courses, including several from freeCodeCamp, Google, Microsoft, and Harvard.

More Free Certificates

If you don’t find what you need here, browse Class Central’s catalog of over 250K courses or visit our thematic collections:

• 2,000+ Free Developer and IT Certifications

• 40+ Free Certificates from Wolfram U

• 10,000+ Free Courses from Tech Giants: Learn from Google, Microsoft, Amazon, and More

• 8000+ OpenCourseWare Courses from Top Institutions.

Without further ado, here are all the free online courses offered by Ivy League institutions.

Brown University (81 courses)

• Reinforcement Learning from Brown University ★★★☆☆(8)

• Machine Learning from Georgia Institute of Technology ★★★★☆(7)

• Machine Learning: Unsupervised Learning from Brown University ★★★☆☆(3)

• Session 4: The habit of judging ourselves and others from Brown University ★★★★★(2)

• Fantastic Places, Unhuman Humans: Exploring Humanity Through Literature from Brown University ★★★★★(1)

• Creating an Inclusive Environment for Sexual and Gender Minority Patients and Trainees in Academic Clinical Settings from Brown University ★★★★☆(1)

• Best Practices for Treatment of Acute Pain: Express Interest and Pre-Survey from Brown University ★★★★★(1)

• Socio-Cognitive Behavioral Therapy for Latinx Youth with Suicidal Thoughts and Behaviors from Brown University ★★★★☆(1)

• On Demand: The Future of Lung Cancer Screening for All Communities in RI: Where We Are and Where We Need to Be from Brown University ★★★★☆(1)

• The Ethics of Memory from Brown University

• Introduction to Engineering and Design from Brown University

• Artful Medicine: Art’s Power to Enrich Patient Care from Brown University

• Beyond Medical Histories: Gaining Insight from Patient Stories from Brown University

• 2022-2023 Department of Psychiatry and Human Behavior Academic Grand Rounds from Brown University

• Session 5: Working with stress and anxiety from Brown University

• CSCI 1730 - Introduction to Programming Languages from Brown University

• On-Demand - Identification and Management of ADHD and Impulse Control in Tourette Syndrome from Brown University

• 2022 - 2023 Child and Adolescent Psychiatry Grand Rounds from Brown University

• Translating understanding of neural network dysfunction into novel, mood disorder risk markers and brain-based treatments for Bipolar Disorder from Brown University

• Social (In)Justice and Mental Health from Brown University

• Parent-Based Treatment for Childhood Anxiety and OCD from Brown University

• On Demand | Demystifying Palliative Care from Brown University

• Social (In)justice and Children’s Mental Health from Brown University

• 9.21.22 5 Ways to Work Through Conflict from Brown University

• School Mental Health, Suicide Prevention, and Wellbeing Promotion: Lessons from the last 10 years & Wisdom for the next 10 from Brown University

• Racism in Academic Psychiatry: Hiding Beneath the Cloak of Our Benevolence from Brown University

• TikTokTherapist: Understanding the Role of Social Media in Adolescent Mental Health from Brown University

• Adolescent Substance Use and Treatment: Translating Science into Clinical Practice from Brown University

• Medical Evaluation of the Sexual Assault Survivor: A Virtual Educational Curriculum from Brown University

• Docs for Health: Considering Social and Structural Determinants in Medical Care from Brown University

• Emergency Care for Opioid Use Disorder from Brown University

• Yoga Intervention Research: Focus on People with Depression from Brown University

• On-demand | Micro-interventions to Support Those Escaping Emotional Pain: Addressing Overlapping Substance Use and Suicide Risk from Brown University

• Session 3: How life gets in the way from Brown University

• Trauma and OUD: Session IV from Brown University

• On-Demand | Building a Better Suicide Risk Assessment: The Nuts and Bolts of the Columbia Protocol from Brown University

• Addressing Microaggressions in the Clinical Environment from Brown University

• Session 2: Compassion the new empathy? Taking the me out of empathy from Brown University

• On Demand | Improving the Care of Patients with Sickle Cell Disease from Brown University

• Rapid-acting Treatments for Pediatric Depression and Suicidality: Where are We Now? from Brown University

• Evidence-based Emergency Care for Opioid Use Disorder from Brown University

• Leveraging Sleep and Circadian Science to Devise and Disseminate Novel Transdiagnostic Treatments to Improve Sleep Health from Brown University

• Screen Media, Social Interaction and ASD: Connecting Theory and Research from Brown University

• Fears, Bias and Discrimination - Substance Use Disorder Patient Care from Brown University

• On-Demand - Advances in the Treatment of Tics from Brown University

• On-Demand | Lethal Means Counseling: Collaboration at the Patient- and Community-Level from Brown University

• Reducing Physician Burnout from Brown University

• Session 1: Feeling the Pain: Empathy and Action from Brown University

• Psychological Flexibility: Building a Pragmatic Model and Method of Intentional Change from Brown University

• Session 6: Spreading Curiosity: Don’t just do something, sit there from Brown University

• Implementation Science: Driving Health Policy Change in Learning Health Systems from Brown University

• EFD On-Demand: Strategic CV Creation and Maintenance from Brown University

• EFD On-Demand: Improving Instruction with Spaced and Retrieval Practice from Brown University

• On-Demand: May 7, 2021: Working with Governments, Institutions, & Stakeholders to Support Healing Relationships & Human Capital; Ethical Stewardship of Shared Data from Brown University

• On-Demand - Transitioning to Adult Care: Time is Ticcing Away from Brown University

• On-Demand: January 8, 2021: Designing Human-Centered Health Information Technology (HIT) & Advancing the Adoption of Patient- Empowering Technology from Brown University

• EFD On-Demand: From Abstract to Poster to Case Report: A Guide for Clinicians from Brown University

• EFD On-Demand: Practical Approaches to Applying Conceptual & Theoretical Frameworks to Medical Education Research from Brown University

• Catatonia, Evaluation, Treatment and Consideration in a Pediatric Population from Brown University

• On Demand | No Longer Speechless - A Practical Workshop on Responding to Microaggressions in Biomedical Settings from Brown University

• The Top “8” Important Facts for Providers to Know About Their Patients with Inflammatory Bowel Disease in 2021 from Brown University

• EFD On-Demand: Engaging the Learner - Active Learning in Didactic Medical Education from Brown University

• Providence Sleep Research Interest Group Seminar Series from Brown University

• Finding the EHR Data to Tell Your Clinical Story: Early Experiences with Lifespan Pediatric Behavioral Health Emergency Services from Brown University

• Academic Detailing: Best Practices for Treatment of Acute Pain from Brown University

• Session 7: The obstacle is the way from Brown University

• Session 8: A Summary of all that we’ve explored from Brown University

• Tom F. Anders Seminar Series from Brown University

• On-Demand - Refractory Tourette Syndrome from Brown University

• Program in Educational Faculty Development On-Demand Courses from Brown University

• 2022 The Patient and The Practitioner in the Age of Technology: Promoting Healing Relationships from Brown University

• DCYF and Legal Considerations: Session VI from Brown University

• EFD On-Demand: Getting Your Scholarly Projects “Unstuck”- A Reference Management Workshop from Brown University

• EFD On-Demand: Critical Junctures: Creating High Impact Advising Conversations from Brown University

• Academic Detailing Group Presentation: Best Practices for Treatment of Acute Pain - Post Activity from Brown University

• 10.06.22 OWIMS Book Club (Session I- Live in-person option): Crucial Conversations from Brown University

• On-Demand: March 5, 2021: Teaching the Use of HIT to Support Relationship-based Care & Promoting Wellness in Clinical Care from Brown University

• 10.06.22 OWIMS Book Club (Session II- Zoom option): Crucial Conversations from Brown University

• Retaining Patients in Office-based Buprenorphine Treatment from Brown University

• EFD On-Demand: You've Been Served: Now What? from Brown University

• EFD On-Demand: Meeting the ACGME Requirement: CQI Education Programs for Residents from Brown University

Columbia University (56 courses)

• Crisis Resource Management from Columbia University ★★★★★(50)

• Frontiers of Science: Climate & Us from Columbia University ★★★★★(22)

• Navigating HOT Moments in the Classroom - Teaching Strategies and Response Framework from Columbia University ★★★★☆(15)

• The Civil War and Reconstruction – 1865-1890: The Unfinished Revolution from Columbia University ★★★★★(8)

• The Civil War and Reconstruction - 1861 - 1865: A New Birth of Freedom from Columbia University ★★★★★(6)

• Space, Time and Einstein from Columbia University ★★★★★(5)

• The Civil War and Reconstruction - 1850-1861: A House Divided from Columbia University ★★★★★(4)

• Special Relativity from Columbia University ★★★★☆(4)

• Pediatric HIV from Columbia University ★★★★☆(3)

• Introduction to Corporate Finance from Columbia University ★★★★★(2)

• Seeking Women’s Rights: Colonial Period to the Civil War from Columbia University ★★★★★(1)

• Risk & Return from Columbia University ★★★★☆(1)

• Global Muckraking: Investigative Journalism and Global Media from Columbia University ★★★★★(1)

• Indian & Tibetan River of Buddhism from Columbia University ★★★★★(1)

• Wage Work for Women Citizens: 1870-1920 from Columbia University ★★★★★(1)

• Find Your Calling: Career Transition Principles for Returning Veterans from Columbia University ★★★★☆(1)

• Fighting HIV with Antiretroviral Therapy: Implementing the Treat-All Approach from Columbia University ★★★★★(1)

• Free Cash Flow Analysis from Columbia University

• Fighting for Equality: 1950–2018 from Columbia University

• Protecting Children in Humanitarian Settings from Columbia University

• Freedom of Expression and Information in the Time of Globalization: Foundational Course from Columbia University

• Learning Success from Columbia University

• Inclusive Teaching: Supporting All Students in the College Classroom from Columbia University

• Negotiating a Changing World: 1920-1950 from Columbia University

• Freedom of Expression and Information in the Time of Globalization: Advanced Course from Columbia University

• Programming & Data Structures from Columbia University

• Attaining Higher Education from Columbia University

• Indigenous Peoples' Rights from Columbia University

• Blended Learning Toolkit from Columbia University

• Essential Math for AI from Columbia University

• Rewriting the Code of Life with CRISPR from Columbia University

• INSPIRE: Seven Strategies for Ending Violence Against Children from Columbia University

• Public Health Advocacy Academy from Columbia University

• University Studies for Student Veterans from Columbia University

• Menstruation in a Global Context: Addressing Policy and Practice from Columbia University

• Digital Case Method from Columbia University

• Supporting Veteran Success in Higher Education from Columbia University

• Soins infirmiers en VIH pédiatrique from Columbia University

• Traitement antirétroviral pour lutter contre le VIH : mise en œuvre de l'approche « traiter tout le monde » from Columbia University

• Economics of Money and Banking from Columbia University

• Effective Teaching Strategies - Science of Learning from Columbia University

• How to Study for Technical Courses from Columbia University

• Virology 1 - How Viruses Work from Columbia University

• Crisis Resource Management - Non-Technical Skills for Effective Healthcare Teamwork from Columbia University

• Crisis Resource Management - Section 2: Preparation from Columbia University

• Glassmaking Techniques and Processes - From Blowing to Fusing from Columbia University

• FOS4 - Foreshadowing - Section 5: Future Climate from Columbia University

• Debunking Climate Myths - Section 5: Future Climate from Columbia University

• Greenhouse Gases - Global Warming: The Earth's Surface from Columbia University

• Memory and Learning - Science of Learning from Columbia University

• New CourseWorks Tutorials for Columbia Faculty and Teaching Assistants from Columbia University

• Ways of Making - Plastic Techniques and Applications from Columbia University

• Creating a Glass Chain Using Flameworking Techniques from Columbia University

• Creating Glass Flowers Through Flameworking Techniques from Columbia University

• Ways of Making - Plastic - Rubber Molds from Columbia University

• Ways of Making - Plastic - Bioplastic from Columbia University

Cornell University (14 courses)

• Database Systems - Cornell University Course (SQL, NoSQL, Large-Scale Data Analysis) from Cornell University ★★★★★(40)

• The Computing Technology Inside Your Smartphone from Cornell University ★★★★★(5)

• Sharks! from Cornell University ★★★★★(5)

• The Science and Politics of the GMO from Cornell University ★★★★★(2)

• Networks, Crowds and Markets from Cornell University ★★★★☆(2)

• Wiretaps to Big Data: Privacy and Surveillance in the Age of Interconnection from Cornell University ★★★★☆(2)

• Structuring Business Agreements for Success from Cornell University ★★★★★(1)

• Teaching & Learning in the Diverse Classroom from Cornell University ★★★★★(1)

• Reclaiming Broken Places: Introduction to Civic Ecology from Cornell University ★★★☆☆(1)

• Foundations of Understanding and Combating Cancer from Cornell University

• Advancing Learning Through Evidence-Based STEM Teaching from Cornell University

• Applications of Machine Learning in Plant Science from Cornell University

• An Introduction to Evidence-Based Undergraduate STEM Teaching from Cornell University

• Nonlinear Dynamics and Chaos from Cornell University

Dartmouth College (231 courses)

• Introduction to Environmental Science from Dartmouth College ★★★★☆(8)

• The Engineering of Structures Around Us from Dartmouth College ★★★★☆(3)

• Question Reality! Science, philosophy, and the search for meaning from Dartmouth College ★★★★☆(3)

• Leadership Lessons from Legends from Dartmouth College ★★★★☆(3)

• C Programming: Modular Programming and Memory Management from Dartmouth College ★★★☆☆(3)

• C Programming: Language Foundations from Dartmouth College ★★★★★(2)

• Linux Basics: The Command Line Interface from Dartmouth College ★★★★★(2)

• C Programming: Pointers and Memory Management from Dartmouth College ★★★★★(2)

• C Programming: Using Linux Tools and Libraries from Dartmouth College ★★★★★(2)

• Retail Fundamentals from Dartmouth College ★★★★☆(2)

• Introduction to Italian Opera from Dartmouth College ★★★☆☆(2)

• Calming and De-Escalation from Dartmouth College ★★★★★(2)

• The American Renaissance: Classic Literature of the 19th Century from Dartmouth College ★★★★★(1)

• John Milton: Paradise Lost from Dartmouth College ★★★★★(1)

• Omnichannel Strategy and Management from Dartmouth College ★★★★☆(1)

• Developing a Trauma-Informed Practice: Four Part Series from Dartmouth College ★★★★★(1)

• Holistic Care Webinar: Introduction to Clinical Hypnosis - Strategies and Skills for Stress Reduction and Improved Communication from Dartmouth College ★★★★★(1)

• Psychiatry Grand Rounds - Social (In)justice and Mental Health from Dartmouth College ★★★★★(1)

• Holistic Care Webinar: Essential Oil Therapy for Nursing Practice from Dartmouth College ★★★★★(1)

• Secondary Traumatic Stress and Burnout from Dartmouth College ★★★★★(1)

• Pediatric Lecture Series - Baron Munchausen to Medical Child Abuse from Dartmouth College ★★★★★(1)

• General Internal Medicine Education Conference 2020 - Management of Hepatitis C in Primary Care 6/25/2020 from Dartmouth College ★★★★★(1)

• Innovation in Nursing: Transforming Care One Nurse at a Time! from Dartmouth College ★★★★☆(1)

• Nursing Grand Rounds Part 4 - Changing the Culture Surrounding Mental Illness: It's Way Past Time from Dartmouth College ★★★★★(1)

• General Internal Medicine Education Conference - Primary Care Education - Integrated Mental Health: Evidence, Policy, and Implementation from Dartmouth College ★★★★★(1)

• Leadership as an Evolving Journey: Mission and Values in Leading Others from Dartmouth College ★☆☆☆☆(1)

• Medicine Grand Rounds - Department of Medicine Case Reports from Dartmouth College ★★★★★(1)

• Nursing Grand Rounds The Intersection of Human Trafficking and Domestic Violence: Is it DV or Could It Be Trafficking? from Dartmouth College ★★★★★(1)

• Medicine Grand Rounds - Under Pressure: Should We Give Hyperbaric Oxygen to COVID-19 Patients? from Dartmouth College ★★★★★(1)

• Medicine Grand Rounds - Department of Medicine Scholarship Enhancement in Academic Medicine (SEAM) Project Reports from Dartmouth College ★★★★★(1)

• Medicine Grand Rounds - Senior Resident in Internal Medicine Research Presentations from Dartmouth College ★★★★★(1)

• Know & Tell for Healthcare Providers from Dartmouth College ★★★★★(1)

• C Programming: Getting Started from Dartmouth College

• Developing Breakthrough Innovations with the Three Box Solution from Dartmouth College

• Libertarian Free Will: Neuroscientific and Philosophical Evidence from Dartmouth College

• Executing Breakthrough Innovations with the Three Box Solution from Dartmouth College

• Introduction to German Opera from Dartmouth College

• C Programming: Advanced Data Types from Dartmouth College

• Communicating Strategically from Dartmouth College

• Bipedalism: The Science of Upright Walking from Dartmouth College

• Crisis Communication and Management from Dartmouth College

• Psychiatry Grand Rounds - Physician Training: A Prospective Model to Understand How Stress Leads to Depression from Dartmouth College

• Corporate Responsibility from Dartmouth College

• Corporate Brand and Reputation from Dartmouth College

• Laying the Groundwork: Adverse Childhood Experiences (ACEs) and their Impact from Dartmouth College

• Psychiatry Grand Rounds - Understanding and Addressing the Psychosocial Needs of Trans and Non-Binary Patients: An Affirming, Effective, and Research-Based Approach from Dartmouth College

• Who are you BECOMING? from Dartmouth College

• Fundamentals of Digital Transformation from Dartmouth College

• Psychiatry Grand Rounds - Treatment of People Who Inject Drugs Hospitalized for Serious Infection from Dartmouth College

• Help for the Helpers: Building a Foundation for Trauma Informed Care from Dartmouth College

• Trauma-Informed Primary Care from Dartmouth College

• Simulation for Digital Transformation from Dartmouth College

• Treatment of Complex Chronic Pain: Are Opioids Helping or Hurting? from Dartmouth College

• Predictive Analytics from Dartmouth College

• Medicine Grand Rounds - Anti-Racism, Healthcare, and Health Policy: How far can we go? from Dartmouth College

• The Link Between Trauma and Substance Misuse: Strategies to Address This in Medical Practice from Dartmouth College

• Nursing Grand Rounds Trauma Informed Care from Dartmouth College

• LWWW Well Talk Self-Care: Practical Ways We Can Take Care of Ourselves and Each Other from Dartmouth College

• Interprofessional Grand Rounds Webinar Series Addressing Sexual Violence: Working Together to Support Survivors (SANE & Law Enforcement) Session 2 of 4 from Dartmouth College

• CHaD Pediatric Lecture Series - Our Student's Emotional and Behavioral Health: Improving Collaboration Between Schools, Families, and Physicians by Focusing on the Child from Dartmouth College

• Medicine Grand Rounds - Cardiovascular Disease and Cancer: Cross-Disease Communication from Dartmouth College

• General Internal Medicine and Primary Care Education Conference - Treating Unhealthy Alcohol Use: What's Our Disorder? from Dartmouth College

• Perianesthesia and Procedural Topics Non-Operating Room Anesthesia from Dartmouth College

• Medicine Grand Rounds - Aging and Dying in Prison: Integrating Geriatrics and Palliative Care into Criminal Justice Reform from Dartmouth College

• Medicine Grand Rounds - COVID-19 as Immunology Boot Camp: Cytokine Release Syndrome & Prospects for Therapy from Dartmouth College

• Prescriptive Analytics from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative: Co-occurring Mental Illness and Substance Use from Dartmouth College

• Medicine Grand Rounds - Structural Heart Disease: Innovation, Implementation & Interdisciplinary Care from Dartmouth College

• Pediatric Lecture Series - Caring for Adolescents with Eating Disorders in Northern New England from Dartmouth College

• Medicine Grand Rounds - Cardiovascular Safety of Urate-Lowering Drugs in Gout from Dartmouth College

• Nursing Grand Rounds Part 2 Changing the Culture Surrounding Mental Illness: It's Way Past Time from Dartmouth College

• Medicine Grand Rounds - Heart Failure with Preserved Ejection Fraction - A Misunderstood Disease in Search of a Therapy from Dartmouth College

• Nonalcoholic Fatty Liver Disease from Dartmouth College

• Vaccine Anxiety in Children from Dartmouth College

• Interprofessional Grand Rounds Webinar Series Addressing Sexual Violence: Working Together to Support Survivors (Child Advocacy Model in Child Abuse Case) Session 4 of 4 from Dartmouth College

• Medicine Grand Rounds - Healing with Intention from Dartmouth College

• Medicine Grand Rounds - Immune-Related Toxicities with Immune Checkpoint Inhibitors from Dartmouth College

• General Internal Medicine Education Conference - Primary Care Education - Osteoporosis related fractures;Deadly but Ignored.....A way forward from Dartmouth College

• Putting Trauma-Informed Care into Practice in the Perinatal Setting (Part 1 of 3) - Foundations for Trauma Informed Care from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative MAT and Telemedicine from Dartmouth College

• Nursing Grand Rounds The 2021 ADA Standards of Care: An Overview of Diabetes Classifications and the Use of Technology in Diabetes Management from Dartmouth College

• DH Ambulatory Nursing Presents The Art of Nursing: Creativity, Growth and Innovation from Dartmouth College

• CHaD Pediatric Lecture Series - The Teen Brain: Decision making, assent, and confidentiality from Dartmouth College

• Medicine Grand Rounds - Implementing Telemedicine in a Chronic Care Model from Dartmouth College

• Nursing Grand Rounds Heart Failure Education: A Guide for Nurses from Dartmouth College

• Interprofessional Grand Rounds Nothing's wrong with them! It's Trauma from Dartmouth College

• Medicine Grand Rounds - Open Questions in Colorectal Cancer Screening from Dartmouth College

• Nursing Grand Rounds Part 6 - Changing the Culture Surrounding Mental Illness: It's Way Past Time from Dartmouth College

• Medicine Grand Rounds - Sex Differences in Obstructive Sleep Apnea Why it Matters, May 8, 2020 from Dartmouth College

• Medicine Grand Rounds - Virtually Better: The Science and Practice of Therapeutic Virtual Reality from Dartmouth College

• Putting Trauma-Informed Care into Practice in the Perinatal Setting (Part 2 of 3) - Caring with Compassion Building Skills for Trauma-Responsive Care from Dartmouth College

• Surgery Grand Rounds June 19, 2020 - Perioperative Management of Pain and Addiction in Patients with Opioid Use Disorder from Dartmouth College

• Nursing Grand Rounds Changing the Culture Surrounding Mental Illness: It's Way Past Time from Dartmouth College

• ECHO Climate & Health: Towards Climate-Informed Care & Advocacy from Dartmouth College

• Nursing Grand Rounds Shattering Silence: Rape Trauma Circa 2021 from Dartmouth College

• Medicine Grand Rounds - Structural Inequity, Racial and Ethnic Disparities and Infectious Diseases: Are There Sustainable Solutions? from Dartmouth College

• Medicine Grand Rounds - Gut Microbiome: Lessons from the REIMAGINE Study, Mark Pimentel, MD, FRCP(C) from Dartmouth College

• Medicine Grand Rounds - How Emerging Science Can Transform Obesity Care from Dartmouth College

• Department of Surgery Grand Rounds - Responsible Opioid Prescribing After Surgery from Dartmouth College

• DH Ambulatory Nursing Presents - Professional Telehealth Nursing: More than a Question, Click, and Conclusion from Dartmouth College

• Medicine Grand Rounds - The Bob Cimis Memorial Lecture - Challenges and Progress Towards the Prevention of Pancreatic Cancer from Dartmouth College

• Medicine Grand Rounds - Opioids and Pain Management: Preventing Harm and Maximizing Benefit from Dartmouth College

• Putting Trauma-Informed Care into Practice in the Perinatal Setting (Part 3 of 3) - Birth Trauma Mitigation and Use of the Plan of Safe Care in Supportive Communication from Dartmouth College

• AXL Enduring Material - Toxicology Testing and Risk Stratification Considerations from Dartmouth College

• Medicine Grand Rounds - Minimal trauma fractures and osteoporosis, deadly but ignored...how do we solve this? from Dartmouth College

• Nursing Grand Rounds Part 3 - Changing the Culture Surrounding Mental Illness: It's Way Past Time from Dartmouth College

• Nursing Grand Rounds Caring for Victims of Non-fatal Strangulation from Dartmouth College

• Medicine Grand Rounds - Have We Found the Holy Grail of Blood Thinners? from Dartmouth College

• Medicine Grand Rounds - Neuro-Axis on Fire: Checkpoint Inhibitor Neuritis / Encephalitis and CAR-T Neurotoxicity. How fast can it burn? from Dartmouth College

• Nursing Grand Rounds Just Another Night of Violence: Brain Injuries from Intimate Partner Violence in New Hampshire from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative - Intersections of Intimate Partner Violence, Opioids, and Trauma: Theory to Practice from Dartmouth College

• Medicine Grand Rounds - The Serrated Pathway and Colorectal Cancer Screening from Dartmouth College

• CHaD Pediatric Lecture Series - Female Athlete Triad 2022: Optimizing Bone Health in Active Female Adolescents from Dartmouth College

• Nursing Grand Rounds Part 5 - Changing the Culture Surrounding Mental Illness: It's Way Past Time from Dartmouth College

• Lung Cancer Screening: An Update and Call to Action from Dartmouth College

• Interprofessional Grand Rounds Webinar Series Addressing Sexual Violence: Working Together to Support Survivors (Advocacy) Session 1 of 4 from Dartmouth College

• Medicine Grand Rounds - Medical Consequences of Climate Change from Dartmouth College

• Medicine Grand Rounds - Team-Based Learning: Engineering Human Performance through Collaboration from Dartmouth College

• Nursing Grand Rounds Finding the Oasis in Food Deserts: Food Access Awareness and Budget Conscious Nutrition from Dartmouth College

• The 2022 Holistic Care Webinar Combustion Avoidance: Communication Strategies to Prevent Interpersonal Conflict from Dartmouth College

• Nursing Grand Rounds Nurses Critical Role in Enhancing Health Literacy from Dartmouth College

• Medicine Grand Rounds - Department of Medicine Scholarship Enhancement in Academic Medicine (SEAM) Project Reports from Dartmouth College

• Surgery Grand Rounds - Bias in the Assessment and Treatment of Pain from Dartmouth College

• Medicine Grand Rounds - Embedding Clinical Trials within Clinical Care: The Future of Learning Healthcare Systems from Dartmouth College

• Interprofessional Grand Rounds Webinar Series Addressing Sexual Violence: Working Together to Support Survivors (Title IX & College Advocacy) Session 3 of 4 from Dartmouth College

• Medicine Grand Rounds - Frail Older Adults and How to Find Them from Dartmouth College

• CHaD Pediatric Lecture Series - Communication after Adverse Events from Dartmouth College

• Medicine Grand Rounds - Insulin @ 100: A Historical Perspective from Dartmouth College

• The 51st Meeting of the NH/VT Ethics Committees: Navigating Decision-Making Capacity amid Mental Illness Uncomfortable Ethical Quandaries Inherent When Psychiatrically Ill Children are Boarded on Non-psychiatric Pediatric Floors Part 3 of 4 from Dartmouth College

• Nursing Grand Rounds Nicotine Addiction 101: What is it and why is it important to you? from Dartmouth College

• The 2022 Trauma Webinar Series Part Four: Geriatric Trauma The Rising Tide from Dartmouth College

• The 2022 Trauma Webinar Series - Part One: Kinematics of Trauma from Dartmouth College

• Medicine Grand Rounds - Post-Acute Sequelae of COVID-19: Lessons in Clinical Care and Health Care Delivery Science from Dartmouth College

• The 51st Meeting of the NH/VT Ethics Committees: Navigating Decision-Making Capacity amid Mental Illness Capacity Assessment Part 1 of 4 from Dartmouth College

• Nursing Grand Rounds Nursing Burnout and Coping Strategies from Dartmouth College

• The 51st Meeting of the NH/VT Ethics Committees: Navigating Decision-Making Capacity amid Mental Illness Eating Disorders Part 2 of 4 from Dartmouth College

• The 2022 Trauma Webinar Series Part Three: Acute Burn Care - The First 24 Hours from Dartmouth College

• Pediatric Grand Rounds - Tackling the Nation's Overdose Crisis: The Role of Pediatric Providers, 5/18/22 from Dartmouth College

• The 2022 Nursing Leadership Webinar Series: When Nurse Leaders Speak, Legislators Listen from Dartmouth College

• Nursing Grand Rounds: HOPE Design Thinking for Nurse Innovators from Dartmouth College

• Interprofessional Grand Rounds Webinar - Human Trafficking Awareness with Homeland Security: NH Updates from Dartmouth College

• Medicine Grand Rounds - Personalized Therapeutics Moving Beyond Precision Medicine from Dartmouth College

• Medicine Grand Rounds - Updates in Polycystic Kidney Disease from Dartmouth College

• Medicine Grand Rounds - Resident Research Presentations from Dartmouth College

• Interprofessional Grand Rounds The Art of Being Human:The Lived Experience of People with Disabilities from Dartmouth College

• Virtual Conversations in Justice and Equity in Bioethics Part 3 of 3: Racism and Health Equity: Why Does it Matter in Bioethics? from Dartmouth College

• Medicine Grand Rounds - Pulmonary Fibrosis - How Epithelial Cells and Fibroblasts Use the Same Language to Drive Each Other Mad from Dartmouth College

• Medicine Grand Rounds - Endocrine Complications of Anorexia Nervosa from Dartmouth College

• Medicine Grand Rounds - An Action Plan toward Gender Equity in a Department of Medicine from Dartmouth College

• The 51st Meeting of the NH/VT Ethics Committees: Navigating Decision-Making Capacity amid Mental Illness Ulysses Clause Part 4 of 4 from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative Medication Assisted Treatment in Vermont Correctional Facilities from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative Providing Care Coordination and Medication to Treat Pregnant and Post-pregnant People for OUD from Dartmouth College

• Interprofessional Grand Rounds Unconscious Bias from Dartmouth College

• Medicine Grand Rounds - Youve Been Thunderstruck! from Dartmouth College

• AXL - Advanced Opioid Use Disorder X-waiver Team Learning Collaborative: Opioid Use Disorders Co-morbid with Alcohol, Sedative, Stimulant, or Tobacco Use Disorders: A Person Centered Approach from Dartmouth College

• Nursing Grand Rounds Excessive Alcohol Use: Nurse's Role in Screening, Brief Intervention (Advice) & Referral for Treatment from Dartmouth College

• Medicine Grand Rounds - Suddenly Meatless: How Tick Bites and Reactions to Red Meat are Changing the Paradigm of Food Allergy from Dartmouth College

• Medicine Grand Rounds - Unconscious Bias: Where are We Now? from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative - Impact of Opioid Use Disorders on Children and Families from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative - Treating Alcohol Use Disorder in Patients Receiving Medication for OUD from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative - Health Disparities & Partner Agencies from Dartmouth College

• Geriatric Education Series - Appropriate Prescribing Practices for Opioids for Pain Management in Older Adults from Dartmouth College

• Nursing Grand Rounds Education and Practice Partnerships in Nursing Education: The Capstone Experience in the RNBS Program at CSC from Dartmouth College

• Nursing Grand Rounds Getting Back to the Basics: Caring for Stroke Patients at Dartmouth-Hitchcock from Dartmouth College

• Medicine Grand Rounds - Myths, Evidence, and the Future of Tobacco Treatment from Dartmouth College

• Virtual Conversations in Justice and Equity in Bioethics Part 2 of 3: Equity in the COVID-19 Pandemic from Dartmouth College

• Virtual Conversations in Justice and Equity in Bioethics Part 1 of 3: Challenging Patient Encounters: Psychologically Informed Patient and Family Centered Care from Dartmouth College

• Medicine Grand Rounds - Early Detection of Pulmonary Fibrosis from Dartmouth College

• Shared Decision Making for Youth Treated with Psychotropic Medications from Dartmouth College

• Medicine Grand Rounds - Why We Need Single Payer from Dartmouth College

• Wicked Pissah Update on Management of Male Voiding Symptoms from Dartmouth College

• Medicine Grand Rounds - Consult Conflict in Medicine from Dartmouth College

• CHaD Pediatric Lecture Series - Pediatric COVID Update from Dartmouth College

• Medicine Grand Rounds - Critical Thinking at the Bedside: Incorporating Uncertainty into your Practice and Teaching - April 24, 2020 from Dartmouth College

• The 2022 Trauma Webinar Series: Part Five Organ Donation from Dartmouth College

• The 16th Ethics Committee Training Day Section Six of Six - Ethics Simulation: A Collaborative Practice of an Ethics Consultation (Must complete sessions 1 5 before registering for this session) from Dartmouth College

• CHaD Pediatric Lecture Series - GERD: Latest Guidelines and Controversies from Dartmouth College

• Nursing Grand Rounds Happy 100th Anniversary to Insulin! Diabetes Update 2021 from Dartmouth College

• Perioperative Patient Care: Leadership in the OR from Dartmouth College

• Medicine Grand Rounds - #MeToo: Addressing Gender Inequity in Academic Medicine from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative - Long-Term OUD Medication Management from Dartmouth College

• Nursing Grand Rounds Education and Practice Partnerships in Nursing Education: The Capstone Experience in the RNBS Program at CSC from Dartmouth College

• Medicine Grand Rounds - When is Enough, Enough? Decision Making Around Colonoscopy in Older Adults from Dartmouth College

• Medicine Grand Rounds - Leveraging Education Technology in our Brave New Medical Education World from Dartmouth College

• Nursing Grand Rounds - Innovation: Translation into Practice from Dartmouth College

• AXL - Opioid Use Disorder X-waiver Team Learning Collaborative - Pain Treatment in Substance Use Disorders from Dartmouth College

• Nursing Grand Rounds COVID-19 Mission: Operation Gotham from Dartmouth College

• Virtual Conversations in Justice and Equity in Bioethics: Controversies Around COVID-19 Vaccines from Dartmouth College

• Nursing Grand Rounds Nursing Advocacy: How YOU Can Make a Difference from Dartmouth College

• Perianesthesia and Procedural Topics Team Nursing from Dartmouth College

• The 16th Ethics Committee Training Day Section Two of Six - What is a Healthcare Ethics Committee from Dartmouth College

• Nursing Grand Rounds Nursing Research Self-Efficacy at an Academic Medical Center from Dartmouth College

• Nursing Grand Rounds - Thriving After a Life-Quake from Dartmouth College

• Medicine Grand Rounds - Equity, Efficiency, and ICU Triage during the COVID-19 Pandemic from Dartmouth College

• DH Ambulatory Nursing Presents - Ambulatory Nurses and Innovation: How Nurses Can Shape Healthcare from Dartmouth College

• Nursing Grand Rounds Team-Based Learning: Engineering Human Performance Through Collaboration (Combined with Medicine Grand Rounds) from Dartmouth College

• The 2022 Trauma Webinar Series Part Two: Massive Transfusion in Traumatically Injured Adults and Children from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative: Managing Injection Behaviors: The Partial Responder to MAT from Dartmouth College

• Medicine Grand Rounds - Discovering VEXAS: the Science of Team Science from Dartmouth College

• Medicine Grand Rounds - Cultivating Empathy in Medicine: What Would Dr. Matthews Say? The Louis B. Matthews Visiting Professorship from Dartmouth College

• Nursing Grand Rounds Year of the Nurse: A Year of Leadership, Advocacy and Activism from Dartmouth College

• The 2022 Nursing Leadership Webinar Series - Part Three: What I Learned about Moving a Medical Center (and How it Impacted the Rest of My Nursing Career) from Dartmouth College

• The 16th Ethics Committee Training Day Section Four of Six - Informed Consent from Dartmouth College

• The 16th Ethics Committee Training Day - Section Three of Six Exploring the Ethical Foundation for Ethics Committees from Dartmouth College

• The Fourth Annual Dartmouth-Hitchcock Nursing Research Symposium - Tackling a problem: Panel on Research, Evidence-Based Practice, and Quality Improvement (Part 2 of 3) from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative - Developing a Stress Resilient Workforce from Dartmouth College

• Medicine Grand Rounds - From the Other Side of the Exam Table from Dartmouth College

• Nursing Grand Rounds Education and Practice Partnerships in Nursing Education: The Capstone Experience in the RNBS Program at CSC from Dartmouth College

• Interprofessional Grand Rounds Webinar - Creating a Trans Affirming Environment: Use of Gender Appropriate Language at Dartmouth-Hitchcock from Dartmouth College

• Nursing Grand Rounds Working with Limited English Proficient Patients and Interpreter Services at Dartmouth-Hitchcock from Dartmouth College

• Nursing Grand Rounds More is Better: Improving Event Reporting in Ambulatory Care from Dartmouth College

• Medicine Grand Rounds - Severe Acute Respiratory Syndrome Coronavirus 2 COVID-19: Science Update, March 20, 2020 from Dartmouth College

• DH Ambulatory Nursing Presents - How the Pandemic can Help us Drive the Implementation of Team-Based Care at DH-H from Dartmouth College

• Medicine Grand Rounds - Recent Advances in the Treatment of Scleroderma, March 13, 2020 from Dartmouth College

• The 16th Ethics Committee Training Day - Section One of Six - Common Presentations of Ethical Concerns brought to a Clinical Ethics Committee from Dartmouth College

• Nursing Grand Rounds Interpreter Services at Dartmouth-Hitchcock: A Deeper Dive from Dartmouth College

• Medicine Grand Rounds - COVID-19: Lessons Learned Over the Past Year. Can We Do Better? from Dartmouth College

• Medicine Grand Rounds - Empathy for the Physician: How COVID Has Reshaped Our Relationships and Lives from Dartmouth College

• Foundations of Epidemiology of Medical Care from Dartmouth College

• The 52nd Meeting of the VT and NH Ethics Committees The Ethics of Rationing from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative - Buprenorphine & Diversion: The Vermont Regulatory Environment. from Dartmouth College

• The 16th Ethics Committee Training Day Section Five of Six - Surrogate Decision Making from Dartmouth College

• AXL: Advanced Opioid Use Disorder X-waiver Team Learning Collaborative - Treating HCV in Spokes from Dartmouth College

• Perianesthesia and Procedural Topics Duty to Patient: Aligns Standards with Clinical Case Scenarios from Dartmouth College

• Nursing Grand Rounds The Force Within: Nursing Innovation and DH's First Nursing Micro Hackathon from Dartmouth College

• The Fourth Annual Dartmouth-Hitchcock Nursing Research Symposium - Keynote: Bedside to Bench to Bedside: Nursing Research to Inform Practice (Part 1 of 3) from Dartmouth College

• APP Precepting Workshop - 4-14-2022 from Dartmouth College

• The Fourth Annual Dartmouth-Hitchcock Nursing Research Symposium - What Can We Do By Next Tuesday? Bringing It All Together and Not Losing Steam (Part 3 of 3) from Dartmouth College

• Medical Care Epidemiology: Patterns, Performance, and Variation from Dartmouth College

• Epidemiology and the Science of Health Care Variation from Dartmouth College

• Medicine Grand Rounds - Haiti after the Earthquake: A Reflection 10 Years, March 6, 2020 from Dartmouth College

Harvard University (357 courses)

• Harvard CS50 – Full Computer Science University Course from Harvard University ★★★★★(1353)

• CS50's AP® Computer Science Principles from Harvard University ★★★★★(227)

• Next in Data Visualization - Michelle Borkin - Radcliffe Institute from Harvard University ★★★★☆(100)

• Justice from Harvard University ★★★★★(60)

• Leadership in Effectively Communicating for Causes and Crises from Harvard University ★★★★★(47)

• CS50's Web Programming with Python and JavaScript from Harvard University ★★★★★(45)

• Advanced Algorithms - COMPSCI 224 from Harvard University ★★★★★(43)

• CS50's Introduction to Artificial Intelligence with Python from Harvard University ★★★★★(38)

• Covering Immigration: A Resource for Journalists from Harvard University ★★★★★(37)

• Exercising Leadership: Foundational Principles from Harvard University ★★★★★(36)

• Mechanical Ventilation for COVID-19 from Harvard University ★★★★★(27)

• CS50’s Computer Science for Business from Harvard University ★★★★★(25)

• Leaders of Learning from Harvard University ★★★★★(23)

• Fundamentals of Neuroscience, Part 1: The Electrical Properties of the Neuron from Harvard University ★★★★★(22)

• Statistics and R from Harvard University ★★★★☆(20)

• The Architectural Imagination from Harvard University ★★★★☆(17)

• Contract Law: From Trust to Promise to Contract. from Harvard University ★★★★☆(16)

• HILT Conference - Making Peer Learning Effective from Harvard University ★★★★★(16)

• Justice with Michael Sandel from Harvard University ★★★★★(15)

• Should Law Foster Forgiveness? Child Soldiers, Sovereign Debt, and Alternatives to Punishment from Harvard University ★★★★☆(15)

• Science & Cooking: From Haute Cuisine to Soft Matter Science (chemistry) from Harvard University ★★★★★(14)

• Human Anatomy: Musculoskeletal Cases from Harvard University ★★★★★(14)

• Principles of Biochemistry from Harvard University ★★★★★(13)

• CS50's Introduction to Programming with Python from Harvard University ★★★★★(13)

• Entrepreneurship in Emerging Economies from Harvard University ★★★★★(12)

• Data Science: R Basics from Harvard University ★★★★★(12)

• Introduction to Linear Models and Matrix Algebra from Harvard University ★★★★☆(12)

• Using Python for Research from Harvard University ★★★★☆(12)

• China’s Political and Intellectual Foundations: From Sage Kings to Confucius from Harvard University ★★★★★(11)

• Therapeutic Cancer Vaccines: Engaging the Immune System Through Science and Art from Harvard University ★★★★★(11)

• Gun Violence: A Public Health Crisis from Harvard University ★★★★★(11)

• Humanitarian Response to Conflict and Disaster from Harvard University ★★★★★(10)

• Religion, Conflict and Peace from Harvard University ★★★★☆(10)

• Religious Literacy: Traditions and Scriptures. from Harvard University ★★★★★(10)

• Improving Global Health: Focusing on Quality and Safety from Harvard University ★★★★☆(10)

• CS50's Introduction to Cybersecurity from Harvard University ★★★★★(10)

• Algorithms for Big Data from Harvard University ★★★★★(10)

• The Health Effects of Climate Change from Harvard University ★★★★★(9)

• Business Transformation through a Culture of Health from Harvard University ★★★★★(9)

• Tangible Things: Discovering History Through Artworks, Artifacts, Scientific Specimens, and the Stuff Around You from Harvard University ★★★★☆(9)

• CS50's Computer Science for Lawyers from Harvard University ★★★★★(9)

• Introduction to Family Engagement in Education from Harvard University ★★★★★(9)

• Modern China’s Foundations: The Manchus and the Qing from Harvard University ★★★★★(8)

• Steven Spielberg's Harvard Commencement Speech on Character, Intuition, and Courage from Harvard University ★★★★★(8)

• Disaster Response - A Decade of Lessons Learned Post-9/11 - The Forum at HSPH from Harvard University ★★★★★(8)

• Fundamentals of Neuroscience, Part 2: Neurons and Networks. from Harvard University ★★★★★(7)

• Fundamentals of Neuroscience, Part 3: The Brain from Harvard University ★★★★★(7)

• Pyramids of Giza: Ancient Egyptian Art and Archaeology from Harvard University ★★★★★(7)

• Christianity Through Its Scriptures from Harvard University ★★★★☆(7)

• Creating Modern China: The Republican Period to the Present from Harvard University ★★★★★(7)

• Data Analysis: Basic Probability and Statistics from Harvard University ★★★★☆(7)

• PredictionX: John Snow and the Cholera Epidemic of 1854 from Harvard University ★★★★★(7)

• CS50's Introduction to Programming with Scratch from Harvard University ★★★★☆(7)

• Birth and the Nation - A Fictional History of Immigration - Stephanie DeGooyer - Radcliffe Institute from Harvard University ★★★★★(7)

• Public Economics - Raj Chetty from Harvard University ★★★★★(7)

• Basic Course in HIV - Resistance and Antiretroviral Therapy from Harvard University ★★★★★(7)

• Data Science: Visualization from Harvard University ★★★★★(6)

• Buddhism Through Its Scriptures. from Harvard University ★★★★☆(6)

• Energy Within Environmental Constraints from Harvard University ★★★★★(6)

• China’s First Empires and the Rise of Buddhism from Harvard University ★★★★★(6)

• Child Protection: Children's Rights in Theory and Practice from Harvard University ★★★★★(6)

• Literati China: Examinations, Neo-Confucianism, and Later Imperial China from Harvard University ★★★★★(6)

• Women's Health and Human Rights - A Lifetime of Advocacy from Harvard University ★★★★★(6)

• From Sea to Changing Sea - Marine Life and Ocean Conservation from Harvard University ★★★★★(6)

• Rhetoric: The Art of Persuasive Writing and Public Speaking from Harvard University ★★★★★(5)

• Shakespeare's Hamlet: The Ghost from Harvard University ★★★★★(5)

• Super-Earths and Life from Harvard University ★★★★☆(5)

• China and Communism from Harvard University ★★★★★(5)

• Invasions, Rebellions, and the Fall of Imperial China from Harvard University ★★★★★(5)

• Remote Work Revolution for Everyone from Harvard University ★★★★★(5)

• Human Rights - Philosophical Inquiries into Nature and Basis from Harvard University ★★★★★(5)

• Where Do We Go From Here? Media, Politics, and Power in the Digital Age from Harvard University ★★★★★(5)

• Clinical Trial Lightning Round: HIV Cure Research Studies at Harvard from Harvard University ★★★★★(5)

• Forensic DNA Testing - Current State and Challenges from Harvard University ★★★★★(5)

• Masterpieces of World Literature from Harvard University ★★★★★(4)

• Cell Biology: Mitochondria from Harvard University ★★★★☆(4)

• Statistical Inference and Modeling for High-throughput Experiments from Harvard University ★★★★★(4)

• Contemporary China: The People's Republic, Taiwan, and Hong Kong from Harvard University ★★★★★(4)

• First Nights - Beethoven's 9th Symphony and the 19th Century Orchestra from Harvard University ★★★★★(4)

• 18th-Century Opera: Handel & Mozart from Harvard University ★★★★★(4)

• Global China: From the Mongols to the Ming from Harvard University ★★★★★(4)

• First Nights - Handel's Messiah and Baroque Oratorio from Harvard University ★★★★★(4)

• Cosmopolitan Tang: Aristocratic Culture in China from Harvard University ★★★★★(4)

• CS50's Introduction to Databases with SQL from Harvard University ★★★★★(4)

• Learn Ancient Greek from Harvard University ★★★★★(4)

• Leading Change: The Convergence of Politics and Policy from Harvard University ★★★★★(4)

• STAT115 2020 from Harvard University ★★★★★(4)

• Understanding the Progression of Neurodegenerative Diseases - Chiara Zurzolo - Radcliffe Institute from Harvard University ★★★★★(4)

• Design Thinking and Innovation - Talking About Teaching Fall 2014 from Harvard University ★★★★★(4)

• Toward a New Global Architecture - America's Role in a Changing World from Harvard University ★★★★☆(4)

• Encontro das Águas - Circulation and Displacement in Art from Harvard University ★★★★★(4)

• Causal Diagrams: Draw Your Assumptions Before Your Conclusions from Harvard University ★★★★★(3)

• Hinduism Through Its Scriptures. from Harvard University ★★★★☆(3)

• Data Science: Building Machine Learning Models from Harvard University ★★★★☆(3)

• Shakespeare’s Othello: The Moor from Harvard University ★★★★★(3)

• First Nights - Monteverdi’s L’Orfeo and the Birth of Opera from Harvard University ★★★★★(3)

• Backyard Meteorology: The Science of Weather from Harvard University ★★★☆☆(3)

• High-Dimensional Data Analysis from Harvard University ★★★★☆(3)

• Data Science: Linear Regression from Harvard University ★★☆☆☆(3)

• Introduction to Data Science with Python from Harvard University ★★★★☆(3)

• From Chemistry to Life from Harvard University ★★★★☆(3)

• Jerusalem: What Sharing a City Means from Harvard University ★★★★★(3)

• Bird Flu Research: Dangerous Information on a Deadly Virus from Harvard University ★★★★★(3)

• It's Complicated - 375 Years of Women at Harvard from Harvard University ★★★★★(3)

• Race, Technology, and Algorithmic Bias - Vision and Justice from Harvard University ★★★★★(3)

• Islam Through Its Scriptures. from Harvard University ★★★★★(2)

• The Opioid Crisis in America from Harvard University ★★★★★(2)

• Leadership for Purposeful Change: Creating Public Value from Harvard University ★★★★★(2)

• United States Health Policy from Harvard University ★★★★★(2)

• Readings in Global Health (2017) from Harvard University ★★★★★(2)

• U.S. Public Policy: Social, Economic, and Foreign Policies from Harvard University ★★★★☆(2)

• The Edges of the Universe from Harvard University ★★★★★(2)

• Prescription Drug Regulation, Cost, and Access: Current Controversies in Context from Harvard University ★★★★★(2)

• Bioethics: The Law, Medicine, and Ethics of Reproductive Technologies and Genetics from Harvard University ★★★★☆(2)

• The Ancient Greek Hero from Harvard University ★★★☆☆(2)

• Technology Entrepreneurship: Lab to Market from Harvard University ★★★★★(2)

• American Government: Constitutional Foundations from Harvard University ★★★★★(2)

• CS50's Mobile App Development with React Native from Harvard University ★★★★★(2)

• Calculus Applied! from Harvard University ★★★★★(2)

• First Nights - Berlioz’s Symphonie Fantastique and Program Music in the 19th Century from Harvard University ★★★★★(2)

• JuryX: Deliberations for Social Change from Harvard University ★★★★★(2)

• Data Science: Probability from Harvard University ★★★★☆(2)

• PredictionX: Omens, Oracles & Prophecies from Harvard University ★★★☆☆(2)

• Data Science: Wrangling from Harvard University ★★★★★(2)

• Introduction to Bioconductor from Harvard University ★★★☆☆(2)

• The Einstein Revolution from Harvard University ★★★★☆(2)

• CS50's Introduction to Programming with R from Harvard University ★★★★★(2)

• The Epidemic of Poverty - The Government Imperative from Harvard University ★★★★★(2)

• Security Paradox - Addressing Modern Security Challenges from Harvard University ★★★★★(2)

• Epidemiology Counts: On Causes, Consequences, and Healthy Populations from Harvard University ★★★★★(2)

• Dark Energy and Cosmic Sound - Exploring the Universe Through Acoustic Waves from Harvard University ★★★★★(2)

• The Health and Economic Concerns of Rural Americans - Forum on Public Health and Policy from Harvard University ★★★★★(2)

• Feminisms Now - Visions of Gender Equality for the 21st Century from Harvard University ★★★★☆(2)

• I Want to Prepare to Learn Something I Don't Know - Gala Porras-Kim - Radcliffe Institute from Harvard University ★★★★★(2)

• Mastering Style: The Learning and Teaching of Writing from Harvard University ★★★★☆(2)

• 3D Printing: Making the Future - From Fundamentals to Advanced Applications from Harvard University ★★★★☆(2)

• Texture and Mouthfeel in Fine Dining - A Menu at Benu from Harvard University ★★★★★(2)

• Slavery and Harvard - Universities and Slavery Series, Part 4 from Harvard University ★★★★★(2)

• The Science of Sugar in Cooking and Baking from Harvard University ★★★★★(2)

• HIV Cure Research Overview - Current Strategies and Future Directions from Harvard University ★★★★★(2)

• Ancient Masterpieces of World Literature from Harvard University ★★★★★(1)

• Global Health Case Studies from a Biosocial Perspective from Harvard University ★★★★★(1)

• Judaism Through Its Scriptures. from Harvard University ★★★★★(1)

• Data Science: Productivity Tools from Harvard University ★★★★★(1)

• Science & Cooking: From Haute Cuisine to Soft Matter Science (physics) from Harvard University ★★★★★(1)

• Women Making History: Ten Objects, Many Stories from Harvard University ★★★★★(1)

• Introduction to Probability from Harvard University ★★★★★(1)

• Poetry in America: Modernism from Harvard University ★★★★★(1)

• U.S. Political Institutions: Congress, Presidency, Courts, and Bureaucracy from Harvard University ★★★★★(1)

• Shakespeare's Life and Work from Harvard University ★★★★★(1)

• Lessons from Ebola: Preventing the Next Pandemic from Harvard University ★★★★★(1)

• Introduction to Digital Humanities from Harvard University ★★★★★(1)

• Data Science: Inference and Modeling from Harvard University ★★★★☆(1)

• Poetry in America: The Civil War and Its Aftermath from Harvard University ★★★★★(1)

• Introduction to Data Wise: A Collaborative Process to Improve Learning & Teaching from Harvard University ★★★★★(1)

• CitiesX: The Past, Present and Future of Urban Life from Harvard University ★★★★★(1)

• Shakespeare's The Merchant of Venice: Shylock from Harvard University ★★★★★(1)

• Poetry in America: Whitman from Harvard University ★★★★☆(1)

• Saving Schools: Reforming the U.S. Education System from Harvard University ★★★★★(1)

• Japanese Books: From Manuscript to Print from Harvard University ★★★★☆(1)

• First Nights - Stravinsky’s Rite of Spring: Modernism, Ballet, and Riots from Harvard University ★★★★★(1)

• Food Fermentation: The Science of Cooking with Microbes from Harvard University ★★★★★(1)

• The Path to Happiness: What Chinese Philosophy Teaches us about the Good Life from Harvard University ★★★★☆(1)

• MalariaX: Defeating Malaria from the Genes to the Globe from Harvard University ★★★★★(1)

• 19th-Century Opera: Meyerbeer, Wagner, & Verdi from Harvard University ★★★★★(1)

• Advanced Bioconductor from Harvard University ★★★☆☆(1)

• PredictionX: Lost Without Longitude from Harvard University ★★★★★(1)

• Structure and Function of Argument: Introduction to Critical Thinking from Harvard University ★★★★☆(1)

• Energy and Thermodynamics from Harvard University ★☆☆☆☆(1)

• Introduction to American Civics: Presented by Zero-L from Harvard University ★★★★★(1)

• Machine Learning and AI with Python from Harvard University ★★★★★(1)

• Fundamental Lessons From String Theory from Harvard University ★★★★★(1)

• Entropy and Equilibria from Harvard University ★★★★★(1)

• We the People: Civic Engagement in a Constitutional Democracy from Harvard University ★★★★★(1)

• Quantitative Social Science Methods from Harvard University ★★★★★(1)

• Deploying TinyML from Harvard University ★★☆☆☆(1)

• Statistics 110 - Probability from Harvard University ★★★★★(1)

• Living Long, Living Well: Aging with Flourish from Harvard University ★★★★★(1)

• STAT115 2018 from Harvard University ★★★★★(1)

• Cooking as a Call to Act - Science and Cooking Public Lecture Series 2018 from Harvard University ★★★★★(1)

• Getting Your Voice into Popular Media - Strategies for Faculty from Harvard University ★★★★★(1)

• Defining Health - How Health and Disease Are Defined in Societies from Harvard University ★★★★★(1)

• Trust: Creating the Foundation for Entrepreneurship in Developing Countries from Harvard University ★★★☆☆(1)

• Contagion - Exploring Modern Epidemics: Infectious Disease - Part 1 from Harvard University ★★★★★(1)

• Prospects for an HIV Vaccine and Cure from Harvard University ★★★★★(1)

• Connectomics: Mapping the Brain's Wiring Diagram from Harvard University ★★★★★(1)

• HILT Conference: Learning from Each Other, Learning Online from Harvard University ★★★★★(1)

• Political Geometry - The Mathematics of Redistricting from Harvard University ★★★★★(1)

• A Political Poetry: Reading and Conversation with Solmaz Sharif from Harvard University ★★★★★(1)

• DNA - Mammoths, Neanderthals, and Your Ancestors from Harvard University ★★★★★(1)

• Plastic in Our Blood: Understanding Health Impacts of Microplastic Exposure from Harvard University ★★★★★(1)

• Gender Equity and Low Fertility in Postindustrial Societies from Harvard University ★★★★☆(1)

• Thinking Like a Magician - Joshua Jay - Radcliffe Institute from Harvard University ★★★★☆(1)

• Policies and Politics of the US Health Care System - Part 1 from Harvard University ★★★★★(1)

• The Evolution of Gene Expression - From Microevolution to Major Transitions from Harvard University ★★★★★(1)

• The Toxic Stress of Early Childhood Adversity - Impact and Interventions from Harvard University ★★★★☆(1)

• From Sea to Changing Sea - The Role of Oceans in Climate from Harvard University ★★★★☆(1)

• Native Law and Legal Strategy - Native Peoples, Native Politics from Harvard University ★★★★★(1)

• Open vs. Closed: Media, Government and Social Organization in the Information Age from Harvard University ★★★★☆(1)

• Economic Crises and Recovery Strategies - The Malcolm Wiener Lecture by Jean-Claude Trichet from Harvard University ★★★★★(1)

• Early Life in the Oceans - From Sea to Changing Sea from Harvard University ★★★★☆(1)

• Developing Trust and Ethically Healthy Organizations Through Humanistic Management from Harvard University ★★★★★(1)

• Janice Wong: Your World, Your Imagination - Art and Texture with Chocolate; Science & Cooking 2019 from Harvard University ★★★★★(1)

• Why Brain Science Needs an Edit - Mu-ming Poo - Radcliffe Institute from Harvard University ★★★★☆(1)

• Leading as a Surgeon and Writer - Atul Gawande on Leadership in Healthcare from Harvard University ★★★★★(1)

• How the Brain Creates Culture - Mind Brain Behavior Distinguished Lecture from Harvard University ★★★★☆(1)

• Avoiding the Oil Curse: The Case of Norway from Harvard University ★★★★★(1)

• The Gorgeous Nothings: Emily Dickinson's Envelope-Poems from Harvard University ★★★☆☆(1)

• Beyond the Nature/Technology Divide - Intersections in Urban Design - Lecture 3 from Harvard University ★★★☆☆(1)

• Next in Data Visualization - Interactive Systems for Intelligence Augmentation from Harvard University ★★★★★(1)

• Trust-Based Management - Practical Ways of Humanizing Business from Harvard University ★★★★★(1)

• Finding Fairness - Incorporating Societal Values in Computer Algorithms from Harvard University ★★★☆☆(1)

• Evolution of Life in the City - Next in Science Series from Harvard University ★★★★☆(1)

• Crafty Crows - Christian Rutz - Radcliffe Institute from Harvard University ★★★★★(1)

• Rights, Duties, and Responsibilities in Citizenship - Part 1 of 4 from Harvard University ★★★★★(1)

• HILT 2019 Conference - Making Peer Learning Accessible from Harvard University ★★★★★(1)

• The Reproducibility Crisis in Historical Perspective from Harvard University ★★★★★(1)

• Archaic Admixture in Human History - Next in Evolution from Harvard University ★★★★☆(1)

• Cancer is Rising Among Younger People - Why? from Harvard University ★★★★☆(1)

• Inclusive Excellence at Harvard and Beyond - A Conversation with John Wilson from Harvard University ★★★★★(1)

• Why School Cellphone Bans Are Spreading from Harvard University ★★★★★(1)

• Navigating Life and Professional Path as a Scholar at Harvard - Faculty Panel 2018 from Harvard University ★★★★★(1)

• Spiritual Ecologies: Sustainability and Transcendence in Contemporary Asia from Harvard University ★★★★☆(1)

• Harvard Horizons Symposium 2014 - Innovative PhD Research Presentations from Harvard University ★★★★★(1)

• Image-Based Learning: From Narrative to New Knowledge - Fall 2014 from Harvard University ★★★★★(1)

• Modern Masterpieces of World Literature from Harvard University

• Innovating in Health Care from Harvard University

• Citizen Politics in America: Public Opinion, Elections, Interest Groups, and the Media from Harvard University

• Building Personal Resilience: Managing Anxiety and Mental Health from Harvard University

• Sikhism Through Its Scriptures. from Harvard University

• Managing Happiness from Harvard University

• China Humanities: The Individual in Chinese Culture from Harvard University

• Strengthening Community Health Worker Programs from Harvard University

• Principles, Statistical and Computational Tools for Reproducible Data Science from Harvard University

• Data Science: Capstone from Harvard University

• Practical Improvement Science in Health Care: A Roadmap for Getting Results from Harvard University

• Justice Today: Money, Markets, and Morals from Harvard University

• Case Studies in Functional Genomics from Harvard University

• Quantitative Methods for Biology from Harvard University

• Early Childhood Development: Global Strategies for Implementation from Harvard University

• Electrochemistry from Harvard University

• ChinaX Book Club: Five Authors, Five Books, Five Views of China from Harvard University

• The Jewish Bible: Its History As A Physical Artifact from Harvard University

• Social Entrepreneurship and Systems Change from Harvard University

• Fundamentals of TinyML from Harvard University

• Digital Humanities in Practice: From Research Questions to Results from Harvard University

• MLOps for Scaling TinyML from Harvard University

• Energy to Electrochemistry Final Exam from Harvard University

• Applications of TinyML from Harvard University

• Family Engagement in Education: The Dual Capacity-Building Framework from Harvard University

• STAT115 from Harvard University

• Visual Storytelling and Comic Communication - A Conversation with Scott McCloud from Harvard University

• Ventilación mecánica para pacientes con COVID-19 from Harvard University

• Writing for Academic and Public Audiences - Professor Duncan White from Harvard University

• The Return of China from Harvard University

• Publish Your Book - Challenges and Solutions in the New Publishing Environment from Harvard University

• The Crisis of Religion and the Logic of the Gods - Hegel's Philosophy of Religion from Harvard University

• Hits and Misses: Sports Marketing, Gender, and Society from Harvard University

• Hidden in Plain Sight - Family Secrets and American History from Harvard University

• Beyond Belief - Exploring the Connection Between Personal Beliefs and Physical Health from Harvard University

• The Writer and the Critic - Marilynne Robinson and James Wood in Conversation from Harvard University

• Where is the Acid? The Science of Flavor in Cooking - Science and Cooking Lecture 2014 from Harvard University

• How to Tell a Story from Harvard University

• Social Justice and the New Food Activism from Harvard University

• A Public Address on Democratic Activism and Rule of Law - Daw Aung San Suu Kyi from Harvard University

• Unquiet Meals Make Ill Digestions - Science and Cooking Lecture Series from Harvard University

• Adoption of Effective Practices in Schools - Todd Rogers - Radcliffe Institute from Harvard University

• Plutocrats with Pitchforks - Understanding American Right-Wing Populism from Harvard University

• Life of a Klansman - Investigating Race Terror in Reconstruction-Era South from Harvard University

• Genetic Prediction of Traits and Diseases Across Diverse Populations - Next in Evolution from Harvard University

• Feeling the Way to Truth - Rethinking Modern Philosophy's Development from Harvard University

• Does the Left Have a Future? - 2017-2018 Dean's Lecture in Social Sciences from Harvard University

• Predicting and Adapting to Increased Hurricane Risk from Harvard University

• Lost Person Behavior - Search and Rescue Strategies from Harvard University

• Animal Navigation - Exploring Migratory Patterns and Mechanisms from Harvard University

• Science and Application of Wearable Technology from Harvard University

• Women, Rights, and Power - Making Democracy from Harvard University

• Boosting Vitamin D: Not Enough or Too Much? - Current Science Controversies from Harvard University

• Ciencia de Datos: Fundamentos de R from Harvard University

• Feeding 10 Billion by 2050 - Creating a Sustainable and Healthy Food Future from Harvard University

• Socialite-Activists and the Black Freedom Struggle - The Glamorous Life from Harvard University

• Universal Health Care - Thailand's Road to Sustainability from Harvard University

• The Case for a Liberal Arts Education: Is It Worth the Investment? from Harvard University

• CS50's Introduction to Computer Science from Harvard University

• Rethinking the American Diet - Environmental and Health Impacts from Harvard University

• In Extremis - Poetry, Subversion and Violence from Harvard University

• Bathsheba Demuth - Do Whales Judge Us? Interspecies History and Ethics from Harvard University

• The Political Ethics of the Strike from Harvard University

• Keeping Up With the Weather - The Future of Data and Forecasting from Harvard University

• Women in Biotech - Defining and Analyzing the Problem from Harvard University

• From Civil War to Civil Rights - The Unending Battle to Vote from Harvard University

• Selassie Atadika - The Science of New African Cuisine; Science & Cooking 2019 from Harvard University

• Contagion - Exploring Modern Epidemics: Big Data in Epidemiology - Part 3 from Harvard University

• Plays with Words - Language and Gender in Comedy from Harvard University

• The Future Utility of DNA Science from Harvard University

• Robert Pinsky Poetry Reading - Selected Poems and New Works from Harvard University

• Integrating Online Courses to Improve Classroom Experience from Harvard University

• Contagion: Exploring Modern Epidemics - Part 2 of 5 from Harvard University

• Ask What You Can Do - Inspiring Public Service from Harvard University

• The Undiscovery of Cosmic Deceleration - Robert P. Kirshner - Radcliffe Institute from Harvard University

• Defining Indigenous Citizenship - Tribal Perspectives and Challenges from Harvard University

• Policies and Politics of the US Health Care System - Part 2 from Harvard University

• Financial Regulation and the CFTC - Gary Gensler's Public Address from Harvard University

• Modernist Cuisine at Home - Lecture 11 (2012) from Harvard University

• Reporting from a Transformed America: Echoes of 9/11 from Harvard University

• An Energy Plan the Earth Can Live With - Climate Protection and Sustainable Innovation from Harvard University

• Why Would We Help Them? - Humanitarian Aid in the Mediterranean Refugee Crisis from Harvard University

• Learning Deeply at Scale: The Challenge of Our Times from Harvard University

• Gender and the Business of Fiction - Influence on Literature and Reception from Harvard University

• Knocking on Heaven's Door - Exploring Fundamental Physics and Cosmology from Harvard University

• Economic Citizenship - Debates on Wealth and Citizenship - Lecture 1 from Harvard University

• Opening Discussion for Measure - Exploring Henrietta Swan Leavitt's Work from Harvard University

• Algorithmic Accountability - Designing for Safety from Harvard University

• New Approaches to Vaccine Development for TB and HIV from Harvard University

• The Temptation of Despair: Tales of the 1940s - Book Discussion from Harvard University

• The Public Philosopher - Healthcare Policy and the American Dream from Harvard University

• Where We Stand in Earthquake Prediction from Harvard University

• Conflicts Over Science and Policy at the EPA - Environmental Challenges and Future Directions from Harvard University

• What Was the Terracotta Army For? - Challenging Common Theories from Harvard University

• The Role of Ethics in Political Art - Changing Political Discussions Through Artistic Integration from Harvard University

• Tiling the Genome - Naming the Parts of Your Genome That Make You You from Harvard University

• Molecules, Movement, and Motors - Shedding Light on Motor Function from Harvard University

• HILT Curriculum Mapping Projects: Improving Curricular Infrastructure at Harvard from Harvard University

• The Gendered Politics of New Nationalisms - Lecture 4 from Harvard University

• The Mad Cartoonists of Cairo - Redrawing the Lines of Acceptable Speech from Harvard University

• The Violent Origin of the Earth and Moon from Harvard University

• CS50 2012 - Week 3 Continued: Search Algorithms and Sorting Techniques from Harvard University

• Rebuild the Dream: The Next American Economy - A Public Address from Harvard University

• The Road to Rescue - Evie Shockley - Radcliffe Institute from Harvard University

• The Fruit Fly as a Research Tool for Human Disease from Harvard University

• The Difficult Miracle: The Living Legacy of June Jordan from Harvard University

• Evolution, Speciation, and Adaptation of Cichlid Fish from Harvard University

• Update on Cryptococcal Disease in HIV-Infected Patients - Lecture 7 from Harvard University

• The Supercommittee Collapse and America's Healthcare Future from Harvard University

• Next in Evolution - The Evolution of Diversity in East African Cichlid Fishes from Harvard University

• Structure in Motion - Geometric Insights in Protein Folding, Robot Kinematics, and Auxetic Materials from Harvard University

• T.S. Eliot's Auditory Imagination - Christopher Ricks Lecture from Harvard University

• The Harvard Campaign Launch - President's Remarks on Shaping the University's Future from Harvard University

• The Arcadia Project - Postmodern Pastoral Poetry Reading from Harvard University

• Reflections on Leading India's National Health Organizations from Harvard University

• Rare Cancers: Charting a Faster Route to Treatment from Harvard University

• Evolutionary Forces in Humans and Pathogens - Natural Selection and Genomic Studies from Harvard University

• Boston Originals - Poetry Readings by Bouchard, Colby, Lepson and Garcia Roberts from Harvard University

• New Search Methods for Primitive and Intelligent Life Beyond Earth from Harvard University

• Harvard Thinking - Why Should You Try the Mediterranean Diet? from Harvard University

• Tracking Shots - Art, Migration, and Citizenship Conversation from Harvard University

• New Faculty Institute 2016 - Perspectives from Recently Tenured Faculty: Navigating Your Professional Path as a Scholar from Harvard University

• The State of the Nation's Housing 2015 - Key Findings and Trends from Harvard University

• The Great Animal Orchestra - Soundscape and Poetry Performance from Harvard University

• New Frontiers in Cancer Care: Advances in Genomics, AI, and Personalized Treatment from Harvard University

• Harvard Commencement Address 2025 from Harvard University

• Harvard Thinking - Preserving Learning in the Age of AI Shortcuts from Harvard University

• Extreme Hurricanes: Challenges and Recovery in Puerto Rico and Beyond from Harvard University

• Your Future Smart Wristband - Wearable Technology for Health and Emotion Monitoring from Harvard University

• Are You Getting Enough Sleep? Probably Not from Harvard University

• How Does Memory Work and Not Work? from Harvard University

• Why Are U.S. Literacy Rates Declining? from Harvard University