Automating GitHub Issue Creation with Claude Code

Creating well-structured GitHub issues is essential for effective project management, but it can be a repetitive and time-consuming task. At Six Feet Up, we've been exploring how to streamline this process using AI.

In this post, I walk through how I used Claude, GitHub CLI, and Claude Code to automate issue creation while maintaining our templates and best practices.

Tedious manual GitHub issue creation

One of the biggest friction points in my workflow was creating detailed GitHub issues. I wanted to minimize the effort required while ensuring every issue followed our organization's templates. Copy-pasting and formatting manually was tedious, and I needed a solution that followed the principle of least action.

The Solution: Claude + GitHub CLI + Claude Code

Our solution leverages a special GitHub repository that contains Six Feet Up’s issue and PR templates. By taking advantage of GitHub's centralized .github repository feature, we ensure that these templates are accessible across all our repositories. This is already a standard part of our workflow.

The breakthrough came when I combined this with Claude and GitHub CLI in a local development environment. Here's how it works:‍

• ‍Claude Code Integration
  
  • We maintain a claude.md configuration file, stored locally, that guides Claude in using our templates.
  • Claude can reference this file and knows how to locate it even when it's in hidden directories, thanks to specific flags and configurations.‍
• Creating Issues Using Prompts
  
  • Using natural language, I can tell Claude to create an issue such as: "Present a logged-in user with a form to collect their comments, including a name field, comment field, and a dropdown for urgency."
  • Claude then selects the appropriate template (e.g., User Story) and fills it in accordingly.
  • I preview the issue and submit it directly using GitHub CLI.‍
• Generating Issues from Meeting Transcripts
  
  • Another powerful use case is extracting issues from meeting transcripts.
  • I point Claude to a transcript file (e.g., from a meeting on a specific date), and it parses it using a predefined structure.
  • Claude generates a list of potential issues, and I select which ones to create.
  • Additional context from the transcript is included in the issue, often capturing more details than I would manually.

Supercharging Automations

During an internal demo, Six Feet Up team members identified several ways to enhance this process further and make it more broadly applicable across teams:

• Codify Best Practices in claude.md: By documenting common branching strategies, formatting conventions, and project-specific standards directly in the configuration file, we ensure consistent quality without extra overhead. Centralizing these best practices and teaching Claude how to apply them also streamlines onboarding and improves team-wide consistency.
• Provide Clear File Paths and Configurations: Explicitly defining file structures and paths in claude.md significantly improves Claude's accuracy and reliability. This ensures Claude accesses the correct templates and transcript files every time — especially when dealing with hidden directories or local variations.
• Empower Claude with Memory and Formatting Rules: Claude can be instructed to remember preferences for specific repositories and even maintain the claude.md file itself. This reduces setup time and helps ensure continuity.
• Integrate with Copilot and GitHub Agents: Combining Claude’s capabilities with GitHub Copilot Agent mode opens the door for deeper automation. Developers can generate, refine, and act on tickets — all from within their local environment.

Team Enablement and Collaboration

Beyond configuration, the team identified opportunities to improve how people interact with the system:

• Refine Human-AI Collaboration: Claude is fast and helpful, but human review is still essential. Using Claude for a first pass lets developers focus their energy on refining, not retyping.
• Lower the Barrier for Collaboration: Encouraging team members to contribute their own workflows and share enhancements to the configuration, we can create a feedback loop that benefits the entire team.

These practices ensure that Claude Code scales with the team by becoming not just a personal productivity tool, but a shared system that reinforces consistency and reduces friction across projects.

Looking Ahead

Using Claude and Claude Code has already transformed how we handle GitHub issue creation at Six Feet Up. The time and energy saved (especially for repetitive or detail-heavy tasks) means developers can stay focused on solving meaningful problems rather than wrestling with formatting or template compliance.

We’re now exploring ways to further scale and systematize this workflow by:

• Embedding project-specific standards (like branching strategies and framework conventions) directly in claude.md.
• Encouraging team members to document their workflows and contribute reusable templates.
• Deepening integrations with AI tooling like GitHub Copilot to support end-to-end development automation.

These next steps will help us create a more consistent, efficient, and collaborative engineering environment — one where developers can rely on AI to handle the busy work, while keeping human creativity and oversight at the core.