inflearn logo

From Ticket to PR — A Development Pipeline Agent Built with Claude Code

Build a development pipeline with Claude Code’s headless mode, where a single-line issue comment triggers a PR ready for review. Codify team rules in CLAUDE.md, skills, and hooks, and add three human approval gates, a review bot, a false-positive ledger, and a cost cap.

1 learners are taking this course

Level Intermediate

Course period Unlimited

claude
claude
github-actions
github-actions
Git
Git
AI Agent
AI Agent
CI/CD
CI/CD
claude
claude
github-actions
github-actions
Git
Git
AI Agent
AI Agent
CI/CD
CI/CD

What you will gain after the course

  • Build and run the pipeline from scratch: comment command → workspace → design notes → tests first → implementation → self-review → PR.

  • Codify team rules such as minimal diffs, TDD, and regression prevention in CLAUDE.md, skills, hooks, and permission settings, then deliberately break them to verify they work.

  • A person reviews the failing tests written by the agent first, then locks them so they can’t be changed during implementation.

  • We build a review bot that labels blockers, decision requests, memo priority, and more, along with a false-positive log that tracks mistaken flags to reduce them.

  • Connect `claude -p` headless execution to the local runner and GitHub Actions, and set per-step costs and a daily budget cap.

  • We measure lead time, time to first review, rework rate, and bot false positive rate using only tracker records.

Final goal — Leave a single '/agent start' comment on an issue, and the agent will create a workspace and carry out the entire process: design memo → failing tests first → implementation → self-check → PR creation. A person makes decisions only at three gates: plan approval, test verification, and merge approval. You’ll complete and run this pipeline yourself on your laptop.

First, I’ll show you the pipeline completed in Lesson 0 taking a single comment all the way to a PR, then in the capstone project in Lesson 23, you’ll build it yourself using your own issue.

Build a development pipeline yourself that delivers a PR ready for review from a single issue comment, using Claude Code headless execution. Encode team rules as code with CLAUDE.md, skills, and hooks, and add three human gates, a review bot, a false-positive ledger, and a cost cap.

What You’ll See in the Level 0 Demo (Actual Run Log)

  • Comment \`/agent start\` on the issue (human) — the watcher wakes up and creates a workspace (branch agent/LM-201 and worktree), then confirms that all 17 existing tests pass.

  • Design memo (agent) — conclusion: 'ready to begin', list of tests to write first → waiting at Gate 1

  • Gate 1 plan approval (human) — \`/agent approve-plan\`

  • Tests first (agent) — tests 17 → 22, app code unchanged → waiting at Gate 2

  • Gate 2 test verification (human) — \`/agent tests-ok\`

  • Implementation → self-check → PR (agent) — all 22 tests pass without changing the verified tests; 2 lines of app code; PR-1 created.

  • Gate 3: Merge approval (human) — Approve → issue complete

  • Record (pipeline) — four-step total: $0.302 · agent time: 80.4 seconds (varies by run)

By the end of this course, you will be able to

  • Build a pipeline from scratch that goes from a comment command → workspace → design notes → tests first → implementation → self-review → PR.

  • We codify team rules like minimal diffs, TDD, and regression prevention in CLAUDE.md, skills, hooks, and permission settings, then deliberately break things to verify they work.

  • When an issue is missing a policy value, make the agent ask the requester instead of guessing.

  • Have the agent write failing tests first, have a person review them, and lock them so they cannot be changed during implementation.

  • Build a review bot that labels feedback as blocking, decision requests, or notes, along with a false-positive ledger to track and reduce incorrect findings.

  • Set an upper limit on revision rounds and caps on retries and budget to prevent infinite AI↔AI revisions.

  • Create a draft PR for the decision function based on policy documents and inquiry records, while leaving anything not covered in the documents as 'unknown'.

  • Connect headless execution with claude -p to a local runner and GitHub Actions, and record costs by step.

  • Measure lead time, time to first review, rework rate, and bot false-positive rate using only tracker records.

What Sets This Course Apart

We focus not on flashy demos, but on “mechanisms that prevent incidents.” Every lesson follows the sequence of trying it out → checking the results → deliberately breaking it, and all the output, costs, and timings shown on screen come from actual execution records. Everything runs using only Python’s standard library and git, with no external packages, and we also provide a fake agent mode for testing the pipeline at zero cost.

Every lesson follows this sequence: follow along → check the results → deliberately break things. You’ll run it yourself to see what breaks when rules are removed or gates are bypassed. People make decisions only at three gates: approving plans, checking tests, and approving merges.

Recommended for teams like these

  • E-commerce, service backend, and frontend developers who want to delegate recurring issue handling and reviews to agents.

  • Lead developers who have introduced AI coding tools to their team but worry that “they don’t follow the rules” and “something might go wrong”

  • Those who have only used Claude Code interactively and want to expand into headless/CI automation.

Curriculum (7 sections · 24 lessons · about 152 minutes)

  • Section 1. End Goal and Practice Environment — Lesson 00: The End Goal: From a One-Line Comment to a PR · Lesson 01: Setting Up the Practice Environment

  • Section 2. Turn Team Rules into Code — Lesson 02: Writing Team Rules in CLAUDE.md · Lesson 03: Configuring Permissions and Secrets · Lesson 04: Enforcing Rules with Hooks · Lesson 05: Bundling the Design Memo Process into a Skill

  • Section 3. From Issue to PR — Lesson 06: Issue Tracker and Comment Commands · Lesson 07: A Workspace for Each Issue · Lesson 08: Design Memos and the 'Needs Confirmation' Rule · Lesson 09: Gate 1: Plan Approval · Lesson 10: Test-First and Gate 2: Test Verification · Lesson 11: Implementation and Retry Limit · Lesson 12: Self-Review and PR

  • Section 4. Review Bots and Human Judgment — Lesson 13: Review Bots and Three Severity Levels · Lesson 14: Reducing False Positives with a Misjudgment Log · Lesson 15: Gate 3 and the Limit on Revision Rounds

  • Section 5. From Documents to Work Items — Lesson 16 Drafting a Decision Function from Policy Documents and Inquiry Records · Lesson 17 Installing It Yourself with a Single Installation Guide

  • Section 6. Headless, Costs, and CI — Lesson 18: Headless Execution with claude -p · Lesson 19: Cost and Permission Management · Lesson 20: CI Integration: Local Runners and GitHub Actions · Lesson 21: A Watcher That Catches Comment Commands

  • Section 7. Measurement and Capstone — Lesson 22: Measuring Impact: Lead Time, First Review, and Rework Rate · Lesson 23: Capstone: See It Through with Your Own Issue

Practice Environment

The ZIP includes a fictional sports and outdoor goods marketplace repository, “Loop Market” (cart, coupon, and order APIs with 17 tests, return policy documents, and customer inquiry records), a file-based issue tracker, pipeline code, a team rules kit (CLAUDE.md, skills, hooks, and permissions), CI workflows, and per-lesson scenarios and the original text of the on-screen lecture output. It runs with the Python standard library, git, and Claude Code, with no external packages. It includes a fake agent mode for testing the pipeline at no cost. There’s also a command mapping table for anyone who wants to use GitHub Issues.

Prerequisites

  • Git basics (branches, commits, and diffs)

  • Basic experience developing web APIs (any language—the practice code is short Python)

  • An account that can run Claude Code (hands-on exercises cost about $0.20–$0.30 per issue based on the course screen; the mock agent exercise is free).

What This Course Does Not Cover

  • Installing Claude Code and Basic Usage (An Introduction to Interactive Use)

  • How to use a specific company’s issue tracker integration SDK (covered instead with a comparison table for File Tracker and GitHub Issues)

  • LLM model training and fine-tuning

Price

Price: KRW 99,000 (including VAT) → KRW 79,200 with a 20% launch discount

Notice

The lecture audio is synthesized (TTS), and the AI responses shown on screen are actual execution results presented without editing. The wording, time, and cost of AI responses may vary each time they are run. All practice data and companies and people are fictional and for educational purposes.

Recommended for
these people

Who is this course right for?

  • E-commerce and service backend/frontend developers who want to delegate the handling and review of recurring issues to an agent.

  • A lead developer who introduced AI coding tools to their team but worries that “they don’t follow the rules” and “their mistakes are scary”

  • For those who have only used Claude Code interactively and want to expand into headless and CI automation.

Need to know before starting?

  • Git Basics (Branches, Commits, and Diffs)

  • Experience developing simple web APIs (any language—the hands-on code will be a short Python exercise)

  • An account that can run Claude Code (including hands-on practice with a fake agent at no cost)

Hello
This is dorian05202988

Career Verified

A data craftsman with over 20 years of experience in databases and IT. As a DBA and manager of a DB Platform team, I work with database platforms and specialize in MySQL, PostgreSQL, Oracle, MongoDB, SQL tuning, AWS, Terraform, and Python. Drawing on experience in the gaming, finance, and IT services industries, I explain database and cloud architecture. I have published 『Oracle Practical Tuning: Learning SQL Patterns』 and 『Oracle Pro*C Practical Project Guide』, and have presented on serverless architectures, database selection, and multi-database strategies at AWS Summit 2018 and 2019 and DataYa Nolja 2020. Recently, I have been working on slow-query analysis and tuning recommendations using Bedrock LLM, automated DB specification sizing, and query workflows through a DB metadata MCP server and Slack bot. I explain database automation for developers and AI applications for non-developers through hands-on exercises tailored to the audience and objectives of each course. Rather than applying AI suggestions as-is, I teach a decision-making framework that verifies result equivalence, execution plans, and observability conditions, and defers action when the supporting evidence is insufficient. Company operational data and credentials are not included in the course materials.

More

Curriculum

All

24 lectures ∙ (2hr 32min)

Course Materials:

Lecture resources
Published: 
Last updated: 

Reviews

Not enough reviews.
Please write a valuable review that helps everyone!

dorian05202988's other courses

Check out other courses by the instructor!

Similar courses

Explore other courses in the same field!

Limited time deal

$61.60

20%

$77.00