DEV Community: Ramu Narasinga

How to build a coding agent - Part 1.0

Ramu Narasinga — Wed, 03 Jun 2026 15:30:00 +0000

In this tutorial series, we build a coding agent that you can assign tasks on GitHub. In this part 1.0, we discuss:

Plan
Architecture
Table of content

This tutorial series is inspired by Multica, an open-source managed agents platform.

The plan

I noticed Multica repository has been trending on GitHub. With Multica, you can assign your GitHub issues to an agent you create via Multica platform and it picks up the work, writes code, report blockers, and update statuses autonomously.

Well, may you could just vibe code this entire Multica clone, but the reason I wrote this series is because I wanted to understand how Multica creates agents, how an issue can be assigend to an agent, how to executes in the background, underlying system architecture.

We use DeepWiki to understand the Multica's codebase architecture apply those principles in the project we build.

Multica uses Go in the backend, we will implement this in Python. Architecture and the concepts will be same, just that we use a different programming language. The goal is not to copy the exact way of Multica's architecture but rather take inspiration and implement.

Architecture

Let's just reiterate the tech stack:

Frontend:

React + Vite
TanStack Query

Backend:

FastAPI (Python)

Goal:

Create an Agent via the UI
Save this Agent info in the database
Assign a task on Github to this agent
Daemon implementation to complete the assigned task.

While we implement the above goals, we study the Multica's architecture and replicate the patterns in our project, frameworks may vary, but the principles would not change.

Table of content

Part 1: Foundation and setup
Part 2: Agent Creation System
Part 3: GitHub Integration
Part 4: Task Assignment System
Part 5: Agent Execution Layer
Part 6: Real-time updates
Part 7: Task Completion and GitHub Sync
Part 8: Advanced features

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

gitrelease.mjs file in Nango codebase.

Ramu Narasinga — Tue, 02 Jun 2026 15:30:00 +0000

In this article, we review gitrelease.mjs file in Nango codebase. You will learn:

gitrelease.mjs file
publish workflow

gitrelease.mjs file

gitrelease.mjs. is defined in the scripts folder and is defined as shown below:

#!/usr/bin/env zx
import { $, echo } from 'zx';

const { GITHUB_TOKEN } = process.env;
const nextVersion = process.argv[3];
const branch = process.argv[4] || 'master';
const nextTag = `v${nextVersion}`;

echo`Publishing ${nextVersion} on branch ${branch}`;

await $`git config --global user.email "contact@nango.dev"`;
await $`git config --global user.name "Release Bot"`;

const tagExists = await $`git tag -l ${nextTag}`;
if (tagExists.stdout !== '') {
    echo`Tag ${nextTag} already exists`;
    process.exit(1);
}

const releaseMessage = `chore(release): ${nextVersion}`;

echo`Checkout out branch`;
await $`git fetch origin ${branch}`;
await $`git switch ${branch}`;

echo`Generating changelog`;
await $`npx git-cliff -o CHANGELOG.md -t ${nextTag}`;

echo`Adding file`;
await $`git add -A package.json package-lock.json packages/**/package.json CHANGELOG.md packages/**/lib/version.ts`;

echo`Creating commit`;
await $`git commit --allow-empty --author="Release Bot <contact@nango.dev>" -m ${releaseMessage} `;

echo`Creating tag`;
await $`git tag -a ${nextTag} HEAD -m ${releaseMessage}`;

echo`Pushing`;
// Rebase on latest to handle commits that landed on ${branch} during publish
await $`git fetch origin ${branch}`;
await $`git rebase origin/${branch}`;
// Push branch and tag separately - tag intentionally points to the pre-rebase commit
await $`git push origin HEAD:refs/heads/${branch}`;
await $`git push origin ${nextTag}`;

echo`Commit pushed, publishing release...`;
// Push GitHub release
const releaseNotes = await $`npx git-cliff --latest --strip header footer`;
const releaseData = JSON.stringify({
    name: nextTag,
    tag_name: nextTag,
    body: releaseNotes.stdout
});

try {
    await $`curl --silent --fail --show-error -H "Authorization: Bearer ${GITHUB_TOKEN}" -H "Accept: application/vnd.github.v3+json" https://api.github.com/repos/NangoHQ/nango/releases -d ${releaseData}`;
} catch (err) {
    console.log(err, releaseData);
    process.exit(1);
}

echo`✅ Done`;

You can follow the echo statements to understand what is happening in the code:

Check out branch
Generating changelog
Adding file
Creating commit
Creating tag
Pushing
Commit pushed, publishing release.

I wrote a separate article about what git-cliff is.

publish workflow

It is a common practice to define scripts and run them in the GitHub workflows. nango/.github/workflows/publish.yaml is defined as below:

name: '[Release] NPM publish'
run-name: '[Release] NPM publish ${{ inputs.version }}'

on:
    workflow_dispatch:
        inputs:
            version:
                type: string
                description: 'Version to publish'
                required: true
                default: '0.0.0'

permissions:
    contents: write
    id-token: write

jobs:
    npm-publish:
        if: github.ref == 'refs/heads/master'
        runs-on: ubuntu-latest
        steps:
            - uses: actions/create-github-app-token@v2
              id: create_github_app_token
              with:
                  app-id: ${{ secrets.GH_APP_PUSHER_ID }}
                  private-key: ${{ secrets.GH_APP_PUSHER_PRIVATE_KEY }}

            - uses: actions/checkout@v4
              with:
                  token: ${{ steps.create_github_app_token.outputs.token }}
                  fetch-depth: 0

            - uses: actions/setup-node@v4
              with:
                  cache: 'npm'
                  node-version-file: '.nvmrc'
                  registry-url: 'https://registry.npmjs.org'

            - name: Update npm to latest
              run: npm install -g npm@11.5.1

            - name: Install dependencies
              run: npm ci

            - name: Publish npm packages
              shell: bash
              run: |
                  npx zx ./scripts/publish.mjs --version="${{ inputs.version }}"

            - name: Publish release
              env:
                  GITHUB_TOKEN: ${{ steps.create_github_app_token.outputs.token }}
              run: |
                  npx zx ./scripts/gitrelease.mjs "${{ inputs.version }}" "${{ github.head_ref || github.ref_name }}"

In the run: section, you will see that this script is invoked using the command:

npx zx ./scripts/gitrelease.mjs "${{ inputs.version }}" "${{ github.head_ref || github.ref_name }}"

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

git-cliff, a changelog generator.

Ramu Narasinga — Mon, 01 Jun 2026 15:30:00 +0000

In this article, we review git-cliff. You will learn:

What is git-cliff?
git-cliff usage in Nango

What is git-cliff?

git-cliff is a highly customizable Changelog Generator that follows Conventional Commit specifications.

High customizable

git-cliff uses regex-powered custom parsers and the changelog can be customized easily with a configuration file to match the desired format.

Conventional Commits

git-cliff can generate changelog files for any Git repository that follows the conventional commits specification.

Easy Integration

git-cliff can be easily integrated with your Rust/Python/Node.js project as a command-line tool and also can be used as a library for Rust projects.

Quick start

Install git-cliff

cargo install git-cliff

Initialise git-cliff:

git-cliff --init

Edit the default Configuration. (cliff.toml) as you like. Check out the

example. for different templates.

Generate a changelog

git-cliff -o CHANGELOG.md

git-cliff usage in Nango

I found the cliff.toml file in Nango codebase. It is defined as shown below.

# git-cliff ~ configuration file
# https://git-cliff.org/docs/configuration

[changelog]
# changelog header
header = """
# Changelog\n
All notable changes to this project will be documented in this file.\n
"""
# template for the changelog body
# https://keats.github.io/tera/docs/#introduction
body = """
{% if version -%}
    ## [{{ version }}] - {{ timestamp | date(format="%Y-%m-%d") }}
{% else -%}
    ## [Unreleased]
{% endif -%}
{% for group, commits in commits | group_by(attribute="group") %}
    ### {{ group | upper_first }}
    {% for commit in commits %}
        - {% if commit.scope %}*({{ commit.scope }})* {% endif %}\
           {{ commit.message | upper_first }}\
           {% if commit.github.username %} by @{{ commit.github.username }}{%- endif -%}
    {% endfor %}
{% endfor %}\n
"""
# template for the changelog footer
footer = """
{% for release in releases -%}
    {% if release.version -%}
        {% if release.previous.version -%}
            [{{ release.version }}]: \
                https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}\
                    /compare/{{ release.previous.version }}..{{ release.version }}
        {% endif -%}
    {% else -%}
        [unreleased]: https://github.com/{{ remote.github.owner }}/{{ remote.github.repo }}\
            /compare/{{ release.previous.version }}..HEAD
    {% endif -%}
{% endfor %}
<!-- generated by git-cliff -->
"""
# remove the leading and trailing whitespace from the templates
trim = true

[git]
# parse the commits based on https://www.conventionalcommits.org
conventional_commits = true
# filter out the commits that are not conventional
filter_unconventional = true
# process each line of a commit as an individual commit
split_commits = false
# regex for parsing and grouping commits
commit_parsers = [
  { message = "^feat", group = "Added" },
  { message = "^.*: add", group = "Added" },
  { message = "^test", group = "Fixed" },
  { message = "^fix", group = "Fixed" },
  { message = "^.*: fix", group = "Fixed" },
  { message = "^chore.release.", skip = true },
  { message = "^.*", group = "Changed" },
]
# protect breaking changes from being skipped due to matching a skipping commit_parser
protect_breaking_commits = false
# filter out the commits that are not matched by commit parsers
filter_commits = true
# regex for matching git tags
tag_pattern = "v[0-9].*"
# regex for skipping tags
skip_tags = ""
# regex for ignoring tags
ignore_tags = ""
# sort the tags topologically
topo_order = false
# sort the commits inside sections by oldest/newest order
sort_commits = "oldest"

You can find the generated Nango's changelog at CHANGELOG.md.

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

Build product integrations with AI using Nango.

Ramu Narasinga — Thu, 28 May 2026 15:30:00 +0000

In this article, we review Nango. You will learn:

What is Nango?
How it works?
Use cases.

What is Nango?

Nango is an open-source platform for building product integrations. It supports 800+ APIs. and works with any backend language, AI coding tool, and agent SDK.

You write integration logic as TypeScript functions, or let AI generate them for you, and deploy to Nango's production runtime. Nango handles auth, execution, scaling, and observability.

Used in production by Replit, Ramp, Mercor, and hundreds more.

Learn more about Nango.

How it works?

Nango gives you three primitives that cover every integration pattern:

1. Auth

Managed OAuth, API keys, and token refresh for 800+ APIs. Embed a white-label auth flow in your app. Nango handles credentials, token storage, and multi-tenant connection management.

// Embed auth in your frontend
nango.openConnectUI({ onEvent: (event) => { /* handle completion */ } });

2. Proxy

Make authenticated API requests on behalf of your users. Send requests through Nango's proxy: it resolves the provider, injects credentials, handles retries and rate limits, and returns the response.

import { Nango } from '@nangohq/node';

const nango = new Nango({ secretKey: '<NANGO-SECRET-KEY>' });

// Make an authenticated request to any API
const response = await nango.get({
    endpoint: '/v3/contacts',
    providerConfigKey: '<INTEGRATION-ID>',
    connectionId: '<CONNECTION-ID>'
});

3. Functions

Write integration logic as TypeScript functions and deploy to Nango. Functions execute on a production runtime with built-in API access, retries, storage, and observability.

Use the AI builder to generate them from a description of your use case.

export default async function run(nango: Nango) {
    const { owner, repo, title, body } = nango.input;

    const response = await nango.post({
        endpoint: `/repos/${owner}/${repo}/issues`,
        data: { title, body }
    });

    return response.data;
}

I copied this above info from theNango README..

Usecases.

I found these following in the Nango docs:

Check out the Nango documentation..

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

DeepWiki, AI documentation you can talk to, for every repo

Ramu Narasinga — Wed, 27 May 2026 15:30:00 +0000

In this article, we review DeepWiki. You will learn:

What is DeepWiki?

What is DeepWiki?

DeepWiki. helps you understand any public repository. You can add a repository using the shown below image.

VSCode Example:

I found this wiki docs for the VSCode codebase https://deepwiki.com/microsoft/vscode.

This is quite powerful, helps you understand any codebase. You can use this to learn the codebase architecture, understand patterns, best practices.

I indexed my own open source project, thinkthroo. It says the indexing process takes anywhere between 2–10 minutes

I found this open source alternative of deepwiki — https://github.com/AsyncFuncAI/deepwiki-open.

Deepwiki-open

AsyncFuncAI/deepwiki-open. provides the following features:

Analyze the code structure
Generate comprehensive documentation
Create visual diagrams to explain how everything works
Organize it all into an easy-to-navigate wiki

DeepWiki is powered by Devin, AI software engineer. For the private repositories, DeepWiki lets you index using Devin.

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

Here is how you can render HTML-based videos using AI coding agent.

Ramu Narasinga — Thu, 21 May 2026 15:30:00 +0000

In this article, we review HyperFrames. You will learn:

What is HyperFrames?
HyperFrames vs Remotion

What is HyperFrames?

Hyperframes is an open-source video rendering framework that lets you create, preview, and render HTML-based video compositions - with first-class support for AI agents.

Getting Started

You want to install the HyperFrames skills:

npx skills add heygen-com/hyperframes

and then, define your prompt. Below is an example prompt:

Using /hyperframes, create a 10-second product intro with a fade-in title, a background video, and background music.

Hyperframes also provides to create a project manually.

npx hyperframes init my-video
cd my-video
npx hyperframes preview # preview in browser (live reload)
npx hyperframes render # render to MP4

I highly recommend reading the HyperFrames README..

HyperFrames vs Remotion

Hyperframes is inspired by Remotion.- we used Remotion at HeyGen in production, learned a ton from it, and kept attribution comments in the source for the patterns it pioneered (Chrome launch flags, image2pipe → FFmpeg streaming, frame buffering). Both tools drive headless Chrome and both are deterministic. They differ on one decision: what the primary author writes. Remotion's bet is React components; Hyperframes' bet is HTML.

I copied this info from the README.

Remotion.also has a feature -Prompt a video.

I also did write an article about how Remotion uses Degit to download template..

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

attw script in CopilotKit codebase.

Ramu Narasinga — Thu, 14 May 2026 15:30:00 +0000

In this article, we review attw script in CopilotKit codebase. You will learn:

What is attw?
attw script in CopilotKit

What is attw?

attw is a CLI for arethetypeswrong.github.io..This project attempts to analyze npm package contents for issues with their TypeScript types, particularly ESM-related module resolution issues. The following kinds of problems can be detected in the node10, node16, and bundler module resolution modes:

💀 Resolution failed.

❌ No types.

🎭 Masquerading as CJS.

👺 Masquerading as ESM.

⚠️ ESM (dynamic import only).

🐛 Used fallback condition.

🤨 CJS default export.

❗️ Incorrect default export.

❓ Missing export =.

🚭 Unexpected module syntax.

🥴 Internal resolution error.

🕵️‍♂️ Named exports.

Below is a check I ran on my npm package, thinkthroo and these were the issues found

attw script in CopilotKit

Since now that we understand what attw does, let’s review how CopilotKit uses this in the package.json script.

I the CopilotKit/packages/agentcore-runner/package.json,. you will find the below code nsippet:

"scripts": {
    ...
    "attw": "attw --pack . --profile node16"
  },

This has two arguments/options/flags passed.

pack

Specify a directory to run npm pack in (instead of specifying a tarball filename), analyze the resulting tarball, and delete it afterwards.

attw --pack .

profile

Profiles select a set of resolution modes to require/ignore. All are evaluated but failures outside of those required are ignored.

The available profiles are:

strict - requires all resolutions
node16 - ignores node10 resolution failures
esm-only - ignores CJS resolution failures

In the CLI: --profile

The script in CopilotKit ignores the node10 resolution failures.

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

Publint usage in CopilotKit codebase.

Ramu Narasinga — Tue, 12 May 2026 15:30:00 +0000

In this article, we review Publint package. You will learn:

What is Publint?
Publint script in CopilotKit codebase.

What is Publint?

publint lints npm packages to ensure the widest compatibility across environments, such as Vite, Webpack, Rollup, Node.js, etc.

How it works?

Given an npm package, the site downloads the tarball and runs publint against it in a web worker. For larger packages, it may take a while to download and lint.

Below are Publint examples, demonstrating how Publint works. This is applied on the Semver package.

Publint script in CopilotKit codebase.

I found the Publint script in the copilotkit/packages/agentcore-runner/package.json.

 "scripts": {
    ...
    "publint": "publint .",
    ...
  },

This script runs publint against the current package, agentcore-runner.

Below is a comment I found above the AgentCoreRunner.

/**
 * AgentCore stores conversation history server-side via AgentCoreMemorySaver /
 * AgentCoreMemorySessionManager. When CopilotKit reconnects to an existing
 * thread (e.g. page refresh), two issues arise that this runner fixes:
 *
 * 1. Unknown threads — CopilotKit may call `connect()` for a thread that has
 *    never had a `run()` (first load). The base runner would error; we emit an
 *    empty snapshot instead so the UI initialises cleanly.
 * 2. Missing tool-call results — AgentCore's replayed history contains assistant
 *    messages with tool calls but no corresponding TOOL_CALL_RESULT events.
 *    CopilotKit needs those to reconcile its message state, so we synthesise
 *    empty results for each past tool call before the snapshot.
 */

Below is another example of Publint on uuid

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

Error handling in Twenty codebase — part 1.1

Ramu Narasinga — Fri, 08 May 2026 15:30:00 +0000

Inspired by BulletProof React,.
I applied its codebase architecture concepts to thestructured, Twenty codebase..

This article focuses only on the error handling strategies used in Twenty codebase..

Approach

In part 1.0, I mentioned that Bulletproof React mentions three ways of error handling:

API errors
In app errors
Error tracking

In this article, I want to provide examples and references to how Twenty handled in-app errors. The approach we take is simple:

Pick onSubmit method in CreateProfile.tsx file..
Review how the error is handled.

In this part 1.0, we review the onSubmit method in CreateProfile.tsx file..

CreateProfile.tsx

CreateProfile modal is rendered during the onboarding on the twenty.com. platform, we will review the onSubmit method:

const onSubmit: SubmitHandler<Form> = useCallback(
    async (data) => {
      try {
        if (!currentWorkspaceMember?.id) {
          throw new Error('User is not logged in');
        }
        if (!data.firstName || !data.lastName) {
          throw new Error('First name or last name is missing');
        }

        await updateWorkspaceMemberSettings({
          ...
        });

        setCurrentWorkspaceMembers((members) =>
          ...
        );

        setCurrentUser((current) => {
          ...
        });

        setNextOnboardingStatus();
      } catch (error: any) {
        enqueueErrorSnackBar({
          apolloError: CombinedGraphQLErrors.is(error) ? error : undefined,
        });
      }
    },
    [
      ...
    ],
  );

This function is wrapped in a try/catch block and the error in the catch block is used in the enqueuErrorSnackBar. What’s this function for? let’s find out.

enqueueErrorSnackBar

enqueueErrorSnackBar is defined as shown below:

import { useSnackBar } from '@/ui/feedback/snack-bar-manager/hooks/useSnackBar';
...
const { enqueueErrorSnackBar } = useSnackBar();

useSnackBar is defined in feedback/snack-bar-manager/hooks/useSnackBar.ts. and it returns the following functions:

return {
    handleSnackBarClose,
    enqueueSuccessSnackBar,
    enqueueErrorSnackBar,
    enqueueInfoSnackBar,
    enqueueWarningSnackBar,
};

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

Custom agents in Microsoft/skills codebase.

Ramu Narasinga — Thu, 07 May 2026 15:30:00 +0000

In this article, we review custom agents in Microsoft/skills repository. You will learn:

What are custom agents?
github/agents in Microsoft skills repo.

What are custom agents?

Custom agents enable you to configure the AI to adopt different personas tailored to specific development roles and tasks. For example, you might create agents for a security reviewer, planner, solution architect, or other specialized roles. Each persona can have its own behavior, available tools, and instructions.

You can also use handoffs to create guided workflows between agents. Transition seamlessly from one specialized agent to another with a single select. For example, move from a planning agent directly into an implementation agent, or hand off to a code reviewer with the relevant context.

I picked the above info from the Custom Agents VS Code docs.. Learn more about how you can
Create Custom agents..

Below is a planning agent example provided in the docs:

---
description: "Generate an implementation plan for new features or refactoring existing code."
name: Planner
tools: ['web/fetch', 'search/codebase', 'search/usages']
model: ['Claude Opus 4.5', 'GPT-5.2']  # Tries models in order
handoffs:
  - label: Implement Plan
    agent: agent
    prompt: Implement the plan outlined above.
    send: false
---
### Planning instructions
You are in planning mode. Your task is to generate an implementation plan for a new feature or for refactoring existing code.
Don't make any code edits, just generate a plan.

The plan consists of a Markdown document that describes the implementation plan, including the following sections:

* Overview: A brief description of the feature or refactoring task.
* Requirements: A list of requirements for the feature or refactoring task.
* Implementation Steps: A detailed list of steps to implement the feature or refactoring task.
* Testing: A list of tests that need to be implemented to verify the feature or refactoring task.

There is a section about how the custom agent file should be structured, Check it out.

I wanted to provide references to custom agents in the OSS repos and I found Microsoft/skills.

Microsoft/skills

Skills repo in Microsoft org provides Skills, MCP servers, Custom Agents, Agents.md for SDKs to ground Coding Agents.

.github/agents in Microsoft skills repo.

I found the following agents defined in the Microsoft/skills repo..

backend.agent.md
frontend.agent.md
infrastructure.agent.md
planner.agent.md
presenter.agent.md
scaffolder.agent.md

frontend.agent.md

In the frontend.agent.md,. below is the structure defined:

---
name: Frontend Developer
description: React/TypeScript specialist for CoreAI DIY frontend development with React Flow, Zustand, and Tailwind CSS
tools: ["read", "edit", "search", "execute"]
---

And has the above table of contents.

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free — thinkthroo.com

References:

Here is how the Github bot is built in Background Agents codebase.

Ramu Narasinga — Tue, 05 May 2026 15:30:00 +0000

In this article, we review the Github bot in Background Agents codebase. You will learn:

What is Background Agents?
What is this Github bot?

What is Background Agents?

Background Agents is an open-source background agents coding system.

Features

Let your whole team ship code. Not just engineers.
Anyone can start. No configuration required.
Requests become PRs, not backlogs
Scale your team without scaling headcount
Meet agents where you work
Every session is collaborative

Learn more about Background Agents..

What is a Github bot?

In the Background Agents codebase, there is a coding agent that uses this Github bot. You will find the below comment in the background-agents/packages/github-bot/src/index.ts.

/**
 * Open-Inspect GitHub Bot Worker
 *
 * Cloudflare Worker that handles GitHub webhook events and provides
 * automated code review and comment-triggered actions via the coding agent.
 */

So this Github bot does the code review and handles actions triggered via comments on the PR.
In this dispatch handler function, you can see the cases handled:

function dispatchHandler(
  env: Env,
  log: Logger,
  event: string | undefined,
  p: Record<string, unknown>,
  payload: unknown,
  traceId: string
): Promise<HandlerResult> {
  switch (event) {
    case "pull_request":
      if (p.action === "opened") {
        return handlePullRequestOpened(env, log, payload as PullRequestOpenedPayload, traceId);
      }
      if (p.action === "review_requested") {
        return handleReviewRequested(env, log, payload as ReviewRequestedPayload, traceId);
      }
      return Promise.resolve({
        outcome: "skipped",
        skip_reason: "unsupported_action",
      });
    case "issue_comment":
      if (p.action === "created") {
        return handleIssueComment(env, log, payload as IssueCommentPayload, traceId);
      }
      return Promise.resolve({
        outcome: "skipped",
        skip_reason: "unsupported_action",
      });
    case "pull_request_review_comment":
      if (p.action === "created") {
        return handleReviewComment(env, log, payload as ReviewCommentPayload, traceId);
      }
      return Promise.resolve({
        outcome: "skipped",
        skip_reason: "unsupported_action",
      });
    default:
      return Promise.resolve({
        outcome: "skipped",
        skip_reason: "unsupported_event",
      });
  }
}

How is Github bot built?

Background agents use Cloudflare Worker to handle GitHub webhook events.

It has these 2 endpoints defined:

app.get("/health", (c) => c.json({ status: "healthy", service: "open-inspect-github-bot" }));

app.post("/webhooks/github", async (c) => {

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.

Get started for free - thinkthroo.com.

References:

util.promisify in Roo-Code codebase.

Ramu Narasinga — Thu, 30 Apr 2026 16:00:00 +0000

In this article, we review promisify method. You will learn:

What is util.promisify?
What is Roo-Code?
Usage example.

What is util.promisify?

Util is a NodeJS API. It has a lot of method defined. Check the util page. We are interested in promisify.

Promisify

Promisify takes a function following the common error-first callback style, i.e. taking an (err, value) => ... callback as the last argument, and returns a version that returns promises.

Below is an example picked from the docs:

import { promisify } from 'node:util';
import { stat } from 'node:fs';

const promisifiedStat = promisify(stat);
promisifiedStat('.').then((stats) => {
  // Do something with `stats`
}).catch((error) => {
  // Handle the error.
});

Learn more about promisify.

What is Roo-Code?

Roo Code gives you a whole dev team of AI agents in your code editor.

What Can Roo Code Do For YOU?

Generate Code from natural language descriptions and specs
Adapt with Modes: Code, Architect, Ask, Debug, and Custom Modes
Refactor & Debug existing code
Write & Update documentation
Answer Questions about your codebase
Automate repetitive tasks
Utilize MCP Servers

Modes

Roo Code adapts to how you work:

Code Mode: everyday coding, edits, and file ops
Architect Mode: plan systems, specs, and migrations
Ask Mode: fast answers, explanations, and docs
Debug Mode: trace issues, add logs, isolate root causes
Custom Modes: build specialized modes for your team or workflow

Learn more about Roo-Code.

Usage example

In the Roo-Code codebase, there is a file, worktree-service.ts. It has promisify imported as shown below, at the top of the file:

import { promisify } from "util"

How is this used? Roo-Code is making two methods return as a promise as shown below:

import { exec, execFile } from "child_process"
import { promisify } from "util"
...
const execAsync = promisify(exec)
const execFileAsync = promisify(execFile)

and then this promisified functions are used in the WorktreeService class as shown below:

/**
 * Service for managing git worktrees.
 * All methods are platform-agnostic and don't depend on VSCode APIs.
 */
export class WorktreeService {
 /**
  * Check if git is installed on the system
  */
 async checkGitInstalled(): Promise<boolean> {
  try {
   await execAsync("git --version")
   return true
  } catch {
   return false
  }
 }
...

About me:

Hey, my name is ramunarasinga. Email: ramunarasinga@gmail.com

Tired of AI slop?

I spent 3+ years studying OSS codebases and wrote 350+ articles on what makes them production-grade. I built

An open source tool that reviews your PR..
Codebase architecture skills, inspired by best OSS projects.