Greg + Code (Greg Baugues) thumbnail

Greg + Code (Greg Baugues)

Claude Code + GitHub WORKFLOW for Complex Apps

đŸŽ„ Claude Code + GitHub WORKFLOW for Complex Apps

⏱ Duration: 18:40
🔗 Watch on YouTube

📚 Video Chapters (10 chapters):

Overview

This video presents a comprehensive, real-world workflow for integrating AI
coding assistants (specifically Claude Code) with GitHub to streamline web app
development. The chapters follow the logical progression of a modern software
development lifecycle—planning, creating, testing, deploying—while highlighting
practical details, challenges, and optimizations when working with AI agents.
Each chapter builds upon the previous, moving from conceptual overview to
hands-on strategies, tools, and nuanced advice for maximizing the power of AI in
solo or small-team software projects.

Chapter-by-Chapter Deep Dive

Overview of the AI Coding workflow (00:00)

Core Concepts & Main Points
- The workflow leverages Claude Code and GitHub to build a web app, unlocking new productivity "superpowers."
- The high-level process: Create GitHub issues → Use Cloud Code slash commands to process issues → Claude plans (using scratchpads), creates code, tests (unit tests & UI tests with Puppeteer), commits, and opens pull requests (PRs) → PRs are reviewed (by human or Claude) → Continuous integration (CI) runs tests and linting on every commit → Use /clear to reset context and repeat.

Key Insights
- Breaking work into small, manageable tasks and automating as much as possible enables effective collaboration with AI.
- CI and automated testing are crucial for safe, fast iteration.

Actionable Advice
- Use slash commands with detailed instructions to guide AI.
- Rely on scratchpads for planning and breaking down issues.

Connection to Overall Theme
- Sets the stage for how AI can be embedded into each aspect of the development lifecycle, emphasizing iteration and automation.

Software Development Life Cycle (01:39)

Core Concepts & Main Points
- The described workflow mirrors the classic plan → create → test → deploy cycle.
- The GitHub Flow (popularized for small teams) suits AI + human collaboration, even for teams as small as one person and one AI agent.

Key Insights
- AI assistants slot naturally into established software engineering processes.
- Human oversight is still essential at key stages, even as AI handles more tasks.

Actionable Advice
- Embrace proven workflows (like GitHub Flow), adapting them for AI collaboration.

Connection
- Reinforces that AI should enhance, not replace, disciplined engineering practices.

Creating and Refining GitHub Issues (03:01)

Core Concepts & Main Points
- Initial issues were created via dictation and refined with Claude, but were too broad and not detailed enough.
- The more granular and specific the issues, the better the AI’s results.
- The human must act as a "manager"—writing specs, reviewing code, giving feedback, and sometimes discarding work.

Key Insights
- Overly optimistic expectations about going directly from generic issues to working code can lead to wasted effort.
- The process requires repeatedly refining and scoping issues for successful AI collaboration.

Actionable Advice
- Invest time upfront in breaking down tasks and writing clear, atomic issues.
- Regularly review and refine issues before assigning to the AI.

Examples
- Early issues included setting up the test suite and CI.
- Modular frameworks (like Rails or Django) help AIs focus on contained areas, reducing cross-cutting complexity.

Connection
- Groundwork for effective AI collaboration is laid by careful, manager-level human oversight in issue creation.

Setting Up Your Foundation (05:54)

Core Concepts & Main Points
- Emphasizes the necessity of a strong foundation: a GitHub repo, continuous integration, a good test suite, and tools like Puppeteer for UI testing.
- Puppeteer allows AI to interact with the browser and test UI features.

Key Insights
- Automation (with CI and testing) is essential before rapid feature iteration.
- Watching AI test UI changes in real-time is both useful and satisfying.

Actionable Advice
- Set up robust automated testing and CI before scaling feature development.
- Use Puppeteer for comprehensive automated UI testing.

Connection
- Once foundational systems are in place, you can harness AI for rapid, safe iteration.

Plan: Custom Slash Commands (07:10)

Core Concepts & Main Points
- Custom slash commands act as prompt templates for instructing Claude on how to process issues.
- The plan step is paramount—Claude uses the GitHub CLI to examine issues, consults scratchpads, and reviews prior PRs for related work.
- Encourages "thinking harder" through prompt engineering ("think hard", "think harder", etc.).

Key Insights
- The more structured and detailed your prompts and planning, the better AI performance.
- Scratchpads serve as persistent, searchable memory for AI planning.

Actionable Advice
- Create, iterate, and refine custom slash commands for each step (planning, coding, testing, deploying).
- Explicitly tell Claude to break down issues and consult prior work.

Connection
- Careful orchestration of AI actions via prompt engineering is crucial for reliable, high-quality results.

Create, Test, Deploy (08:59)

Core Concepts & Main Points
- Discusses the debate over how much to trust AI with code generation and commits.
- Emphasizes human responsibility for code quality, regardless of who writes it.
- Testing provides critical safety net; not aiming for 100% coverage, but for high confidence that new features don’t break existing functionality.
- Deployment is automated via services like Render, triggered by merging to the main branch.
- PRs are the focal point for code review and discussion—by human or AI (with custom review slash commands).

Key Insights
- Even with AI, humans must review, understand, and take ownership of code before merging.
- Automated tests are non-negotiable for confidence in AI-generated changes.
- PR reviews, especially with stylistic prompts ("review in the style of Sandy Metz"), can catch maintainability issues.

Actionable Advice
- Review all PRs, either personally or via a fresh AI session with a clean context.
- Use custom review commands and leverage respected coding standards/styles.
- Automate deployment with CI/CD pipelines triggered by GitHub.

Connection
- AI boosts productivity, but the human remains the gatekeeper for quality and standards.

Your job vs. AI's job (13:29)

Core Concepts & Main Points
- Clarifies the division of responsibilities: humans should focus on planning (hard to delegate), while AI can handle much of the creation, testing, and deployment.
- Planning quality directly impacts project success.

Key Insights
- Effective delegation to AI requires detailed, well-thought-out planning.
- Issues should be self-contained so AI can handle them independently.

Actionable Advice
- Invest most human effort in crafting and refining issues.
- Delegate as much as possible of the mechanical coding/testing to AI.

Connection
- The workflow is most efficient when the human acts as a product/engineering manager, not a code monkey.

Context Management with /clear (14:32)

Core Concepts & Main Points
- Using /clear resets Claude’s context window after each issue.
- Each issue must contain all necessary information—AI should work from a “cold start.”

Key Insights
- Clearing context prevents AI confusion (“context pollution”) and reduces token usage.
- Properly constructed issues and scratchpads enable stateless, repeatable AI tasks.

Actionable Advice
- Use /clear after each issue to maintain clean context.
- Ensure issues are self-contained with all required background.

Connection
- Effective context management is essential for scalable, reliable AI collaboration.

Claude via GitHub Actions (15:07)

Core Concepts & Main Points
- Claude can now be triggered via GitHub Actions (by tagging in PRs/issues) for direct, in-repo automation.
- However, this incurs metered API billing, even on premium plans.

Key Insights
- Using the console may be more cost-effective and insightful for larger tasks.
- GitHub Actions is best reserved for small tweaks or minor reviews, not substantial code changes.

Actionable Advice
- Use Claude via GitHub Actions for minor, quick fixes or copy changes.
- For major work, stick to the console to avoid unexpected costs and maintain better control.

Connection
- Choosing the right tool and interface for the task optimizes both cost and workflow efficiency.

Work Trees: Run Parallel Agents (16:28)

Core Concepts & Main Points
- Git work trees allow running multiple Claude instances in parallel, each working on a different branch/issue.
- Analogous to “multitabling” in online poker—handling several tasks at once.

Key Insights
- While parallel agents are promising, they add operational overhead (e.g., permissions management, merge conflicts).
- For early-stage or highly interdependent projects, serial work may be simpler and more effective.

Actionable Advice
- Consider work trees and parallel agents only when your project and workflow are mature and tasks are independent.
- Clean up work trees and manage permissions carefully to avoid clutter/conflicts.

Connection
- Parallelism can boost productivity but is not always worth the added complexity.

Cross-Chapter Synthesis

Several themes bridge multiple chapters:
- Human-AI Collaboration: Humans act as planners and reviewers (Ch. 3, 6, 7), while AI excels at execution given clear direction (Ch. 4, 5, 6).
- Iterative Planning & Refinement: Effective workflows depend on granular, well-scoped issues (Ch. 3, 5, 7).
- Automation & Testing: Automated CI, testing, and deployment (Ch. 4, 6) are foundational for safe, fast iteration with AI.
- Prompt Engineering: Custom slash commands and scratchpads (Ch. 5) are critical for guiding AI behavior and memory.
- Context Management: Resetting context (Ch. 8) and ensuring issues are self-contained are vital for consistent results.
- Pragmatic Tool Use: Weighing the pros and cons of console use vs. GitHub Actions, and parallelism with work trees (Ch. 9, 10).

Progressive Learning Path

The video guides viewers through a logical learning journey:
1. Big Picture Overview (Ch. 1-2): Introduces the AI-powered workflow, situating it within established software engineering practices.
2. Laying the Foundation (Ch. 3-4): Emphasizes the importance of granular planning, robust test suites, and CI.
3. Detailed Execution (Ch. 5-6): Demonstrates how to orchestrate AI tasks via custom commands, code generation, testing, and deployment.
4. Division of Labor (Ch. 7): Clarifies which tasks humans should focus on
vs. delegate to AI.
5. Optimization & Scaling (Ch. 8-10): Explores advanced topics like context
management, cost control, and parallel workflows.

Key Takeaways & Insights

  • Clear, Atomic Issues Are Crucial (Ch. 3, 5, 7): Project success hinges on detailed, well-scoped task definition.
  • Automated Testing Safeguards Quality (Ch. 4, 6): A solid test suite and CI/CD are non-negotiable for safe, scalable AI-assisted development.
  • Human Oversight Remains Essential (Ch. 3, 6, 7): AI augments, but does not replace, the need for review, planning, and judgment.
  • Prompt Engineering Drives AI Success (Ch. 5): Custom commands and scratchpads enable more effective and reliable AI performance.
  • Context Reset Prevents Errors (Ch. 8): Use /clear and self-contained issues to avoid context creep and token bloat.
  • Practical Tool Choices Matter (Ch. 9-10): Optimize cost and efficiency by choosing the right interface and workflow for each task.

Actionable Strategies by Chapter

Ch. 1-2:
- Adopt a cyclical plan-create-test-deploy workflow with AI.
- Use GitHub Flow as a process backbone.

Ch. 3:
- Break down features into tightly scoped issues before involving AI.
- Continually refine tasks and requirements.

Ch. 4:
- Set up CI and automated testing before accelerating feature development.
- Use Puppeteer for UI testing.

Ch. 5:
- Create and iterate on custom slash commands.
- Use scratchpads for persistent planning and reference.

Ch. 6:
- Personally review all AI-generated PRs, or use fresh AI sessions for PR review.
- Use automated deployment services linked to GitHub.

Ch. 7:
- Focus human energy on planning and scoping; let AI handle repetitive execution.

Ch. 8:
- Use /clear after every issue to reset context.
- Ensure issues are fully self-contained.

Ch. 9:
- Use Claude via GitHub Actions for minor, quick changes; otherwise, prefer the console to control costs.

Ch. 10:
- Use work trees for parallel development only when tasks are independent and you're comfortable with added complexity.

Warnings & Common Mistakes

  • Overly Broad Issues Lead to Failure (Ch. 3): Don’t expect good outcomes from vague or high-level tasks.
  • Neglecting Testing and CI Is Risky (Ch. 4, 6): Lack of automation increases the risk of regressions and slows development.
  • Over-trusting AI With Commits/Reviews (Ch. 6): Always review AI-generated code before merging to main.
  • Context Pollution (Ch. 8): Not resetting context can lead to errors or increased costs.
  • Unexpected API Charges (Ch. 9): Using GitHub Actions with Claude can quickly incur extra fees, even on premium plans.
  • Parallelism Overhead (Ch. 10): Work trees can add complexity and require frequent manual intervention if not managed carefully.

Resources & Next Steps

Ch. 3:
- GitHub CLI for AI integration
- Alternative: MCP server (if CLI unavailable)

Ch. 4:
- Puppeteer for browser-based automated testing

Ch. 5:
- Anthropic’s best practices posts (e.g., Boris’s agent prompting guide)

Ch. 6:
- Article: “All of My AI Skeptic Friends Are Nuts” by Thomas Tacic
- Automated deployment services (e.g., Render)

Ch. 9:
- Claude Max plan for unlimited console use
- GitHub Actions integration (for small, targeted tasks)

Ch. 10:
- Git work trees documentation for running parallel codebase branches

General Next Steps:
- Review the referenced video on Claude Code pro tips for advanced usage strategies.

This summary provides a chapter-by-chapter breakdown, synthesizes recurring
themes, and offers actionable advice, warnings, and resources—all mapped
explicitly to the video’s structure for easy navigation and deeper
understanding.

← Back to Greg + Code (Greg Baugues) Blog