DEV Community: Hardik Soni

DebugHook: A New Take at Debugging using AI Agents

Hardik Soni — Mon, 16 Feb 2026 07:57:42 +0000

This is a submission for the GitHub Copilot CLI Challenge

What I Built

DebugHook is an attempt to add the missing debug mode to terminal agents. When agents run or generate code in the terminal, there’s usually no way to step through execution or inspect state—you’re left with logs, print statements, or replaying the same command and hoping to spot the bug. This project hooks tools like pdb (Python) and lldb (native/LLVM) into that flow so you can set breakpoints, step through, and inspect variables in agent-executed code, bringing traditional debugging to the terminal-agent workflow.

The idea came from a recent project where I was working with terminal agents and hit a lot of bugs. I spent a lot of time chasing issues in code that the agent had generated or run: wrong assumptions, off-by-ones, bad state—and no good way to pause and inspect. I had to pick up each bug manually, add prints, re-run, and reason from partial output. That friction is what pushed me to build something in this direction: a way to break in when the agent runs code, use the same debuggers I’d use for my own code (pdb, lldb), and step through instead of guessing from logs.

What it takes to use it (and what’s needed to build it): You need a terminal agent workflow (e.g. GitHub Copilot CLI or similar) that runs or generates code. DebugHook sits in that pipeline so that when the agent executes Python or native code, execution can be handed off to pdb or lldb instead of running to completion. On the tooling side: pdb (built into Python) or lldb (LLVM debugger) installed, and a way to intercept or wrap the agent’s execution (e.g. running the agent’s code in a subprocess or through a runner that can spawn a debugger). What I built is the direction and glue for that—the “debug mode” that was missing—so that the same workflows you use for normal development (breakpoints, step, inspect) apply when the code is coming from an agent.

Demo

https://drive.google.com/drive/folders/1_9LZHS29Ed53hkM0c327DezEYrnLz9TQ?usp=sharing

Github Repo: https://github.com/hs094/DebugHook

My Experience with GitHub Copilot CLI

What I used it for: I used GitHub Copilot CLI while building DebugHook for scaffolding, exploring how to wire pdb/lldb into an agent execution path, and for quick refactors and debugging of my own code. It helped with boilerplate (e.g. runner scripts, subprocess handling), with understanding existing debugger APIs (pdb’s programmatic use, lldb’s Python bindings), and with iterating on the “glue” between the terminal agent and the debugger.

What I learned: The main takeaway was how much faster I could move when I could describe the goal (e.g. “run this script under pdb and capture the first breakpoint”) and get a first version of the integration code, then refine it. I also learned where Copilot CLI shines—repetitive patterns, API lookup, small fixes—and where I still had to think carefully (architecture of when to hand off to the debugger, handling stdin/stdout for pdb in a subprocess). Another learning: it was useful to break the work into small, testable steps and prompt for each step, rather than asking for the whole flow at once.

Impact on the experience: Having Copilot CLI in the loop made it easier to try different ways of hooking the debugger (e.g. python -m pdb, or embedding pdb in the runner) without getting stuck on syntax or docs. When I hit bugs in my code while building DebugHook, I could describe the symptom and get suggested fixes or tests, which kept the focus on the “debug mode for agents” idea instead of on boilerplate. If I were to do it again, I’d lean on it earlier for the subprocess and TTY handling around pdb, since that was one of the trickier parts.

Great learning on Serverless architecture usecase!

Hardik Soni — Tue, 27 May 2025 15:35:06 +0000

Shayan

May 20 '25

The Serverless Dream Is Dead

#webdev #programming #javascript #beginners

Comments 23

4 min read

🚀 QForge — AI-Powered CI/CD Pipeline Generator from Your CLI

Hardik Soni — Sun, 11 May 2025 19:31:52 +0000

This is my submission for the Amazon Q Developer “Quack The Code” Challenge: Crushing the Command Line.

Hey builders! 👋

I’m excited to introduce QForge — a smart, AI-driven CLI tool that automates the generation of robust, secure, and self-healing CI/CD pipelines using Amazon Q Developer CLI.

No copy-pasting YAMLs. No trial-and-error configs. Just a single command to get it all done.

📦 GitHub Repository

🛠️ Built With: TypeScript, Node.js, Amazon Q Developer CLI

💡 The Idea

Setting up CI/CD pipelines for multi-language projects is painful and error-prone — especially when you need to add coverage gates, security scans, and resilience.

QForge was created to automate this completely, using deep codebase analysis and the power of Amazon Q Developer to generate intelligent, tailored pipelines for GitHub Actions, AWS CodePipeline, GitLab CI, or CircleCI.

🤖 How It Works

Here's how QForge gets you from zero to production-grade pipeline:

🔍 Project Analysis
- Analyzes your codebase using custom analyzers for Ruby, Go, Rust, PHP, .NET, and more.
- Detects languages, frameworks, test tools, build systems, and special characteristics.
📦 Prompt Generation
- Constructs a highly tailored prompt using your project’s context and chosen CI/CD platform.
🤖 Amazon Q CLI Integration
- Sends the prompt to Amazon Q CLI to generate a pipeline with all requested features:
  - Test coverage
  - Linting
  - Security scanning
  - Self-healing automation
🛠️ Output
- Saves a production-ready pipeline YAML (e.g., ci.yml, aws-pipeline.yml) into your project directory.

🚀 Getting Started

1️⃣ Install Dependencies

npm install
npm run build
npm link

Make sure you have:

Node.js ≥ 16
Amazon Q Developer CLI installed (pip install amazon-q-cli)

2️⃣ Authenticate Amazon Q

q login

🧪 Usage

▶️ Generate Pipeline

qforge generate

By default, this analyzes your current directory and generates a GitHub Actions workflow.

▶️ Customize Options

qforge generate --platform aws --directory ./my-project --output ./ci/aws-pipeline.yml

Available platforms:

github
aws
gitlab
circleci

Use --yes to skip confirmation prompts.

📄 Sample Output (GitHub Actions)

name: CI Pipeline

on:
  push:
    branches:
      - main
  pull_request:

jobs:
  build:
    runs-on: ubuntu-latest
    steps:
      - name: Checkout code
        uses: actions/checkout@v3

      - name: Setup Node.js
        uses: actions/setup-node@v3
        with:
          node-version: 18

      - name: Install dependencies
        run: npm install

      - name: Lint
        run: npm run lint

      - name: Run tests with coverage
        run: |
          npm run test -- --coverage
          npm run coverage:check

      - name: Security scan
        run: npm audit --audit-level=critical

      - name: Build project
        run: npm run build

✅ Fully-commented AWS CodePipeline templates are also supported via --platform aws.

🧪 Tests

QForge includes a test suite powered by Jest. Example:

npm run test

Test coverage thresholds are enforced and configurable:

// jest.config.js
coverageThreshold: {
  global: {
    branches: 20,
    functions: 40,
    lines: 25,
    statements: 25
  }
}

You can also test prompts independently:

npm run test:prompt:aws

✨ Why You’ll Love It

QForge:

✅ Saves hours of manual YAML wrangling

🧠 Uses deep project analysis to optimize CI/CD pipelines

🔐 Adds security and test coverage gates automatically

🛠️ Enables self-healing for resilient pipelines

🤝 Works seamlessly with Amazon Q CLI

🔭 What’s Next

Coming soon:

📊 CI Coverage Dashboard
🧩 VS Code integration
🦺 Linter for pipeline configurations
🦾 Auto-fix for failed builds based on logs

🧠 Final Thoughts

QForge is built to remove friction and empower developers to deliver faster and safer. Thanks to Amazon Q Developer CLI, it bridges code understanding with intelligent automation — all from the CLI.

Let your pipelines write themselves! 🔧🧠

Let me know what you think or drop a ⭐️ on the GitHub repo if you find it helpful!