bl-record

Record changes as a new commit in git-branchless workflow

9 stars

Best use case

bl-record is best used when you need a repeatable AI agent workflow instead of a one-off prompt.

Record changes as a new commit in git-branchless workflow

Teams using bl-record should expect a more consistent output, faster repeated execution, less prompt rewriting.

When to use this skill

  • You want a reusable workflow that can be run more than once with consistent structure.

When not to use this skill

  • You only need a quick one-off answer and do not need a reusable workflow.
  • You cannot install or maintain the underlying files, dependencies, or repository context.

Installation

Claude Code / Cursor / Codex

$curl -o ~/.claude/skills/bl-record/SKILL.md --create-dirs "https://raw.githubusercontent.com/jpoutrin/product-forge/main/plugins/git-workflow/skills/bl-record/SKILL.md"

Manual Installation

  1. Download SKILL.md from GitHub
  2. Place it in .claude/skills/bl-record/SKILL.md inside your project
  3. Restart your AI agent — it will auto-discover the skill

How bl-record Compares

Feature / Agentbl-recordStandard Approach
Platform SupportNot specifiedLimited / Varies
Context Awareness High Baseline
Installation ComplexityUnknownN/A

Frequently Asked Questions

What does this skill do?

Record changes as a new commit in git-branchless workflow

Where can I find the source code?

You can find the source code on GitHub using the link provided at the top of the page.

SKILL.md Source

# /bl-record - Git-Branchless Record

**Category:** Git Workflow

Record staged/unstaged changes as a new commit using git-branchless. Optionally create a branch for the commit.

## Usage

```
/bl-record [-m <message>] [--create-branch]
```

## Options

| Option | Description |
|--------|-------------|
| `-m <message>` | Commit message (required) |
| `--create-branch` | Create a branch for PR submission (uses `-c` flag) |

## Examples

```bash
# Record with message
/bl-record -m "feat: add user validation"

# Record and create branch for PR
/bl-record -m "fix: handle null input" --create-branch
```

## Execution Instructions

1. **Check Prerequisites**
   - Verify git-branchless is installed
   - Verify repository is initialized for branchless
   - Check we're in detached HEAD state

2. **Stage Changes (if needed)**
   - Run `git status` to check for changes
   - If unstaged changes exist, run `git add -A` to stage all

3. **Record the Commit**
   - If `--create-branch` is provided:
     ```bash
     git branchless record -c -m "<message>"
     ```
     Then immediately return to detached HEAD:
     ```bash
     git checkout --detach
     ```
   - Otherwise:
     ```bash
     git branchless record -m "<message>"
     ```

4. **Show Result**
   - Run `git sl` to display the updated stack
   - Confirm the new commit was added

## Flow Examples

```
User: /bl-record -m "feat: add user model"

Agent: Recording changes...

Staged changes:
  A src/models/user.py
  M src/models/__init__.py

Running: git branchless record -m "feat: add user model"

◆ abc1234 (main) initial commit
┃
● def5678 feat: add user model  ← New commit

Commit recorded successfully.
```

```
User: /bl-record -m "fix: validate email" --create-branch

Agent: Recording changes with branch creation...

Staged changes:
  M src/validators.py

Running: git branchless record -c -m "fix: validate email"
Branch created: fix-validate-email

Returning to detached HEAD...
Running: git checkout --detach

◆ abc1234 (main) initial commit
┃
● ghi9012 fix: validate email (fix-validate-email)  ← New commit with branch

Commit recorded with branch for PR submission.
Use /bl-submit to push the branch.
```

## Error Handling

| Error | Resolution |
|-------|------------|
| No changes to record | Inform user there's nothing to commit |
| Not in detached HEAD | Warn and suggest `git checkout --detach` |
| git-branchless not installed | Provide installation command |
| Repo not initialized | Suggest `/bl-init` |

## Why Detach After Branch Creation?

When using `-c` to create a branch, git-branchless checks out that branch. We immediately detach again to maintain the branchless workflow where you work in detached HEAD and only create branches when submitting PRs.

Related Skills

zod

9
from jpoutrin/product-forge

Zod schema validation patterns and type inference. Auto-loads when validating schemas, parsing data, validating forms, checking types at runtime, or using z.object/z.string/z.infer in TypeScript.

typescript-import-style

9
from jpoutrin/product-forge

Merge-friendly import formatting (one-per-line, alphabetical). Auto-loads when writing TypeScript/JavaScript imports to minimize merge conflicts in parallel development. Enforces consistent grouping and sorting.

setup-mcp-auth

9
from jpoutrin/product-forge

Configure authentication for an existing FastMCP server

fastmcp

9
from jpoutrin/product-forge

FastMCP TypeScript framework patterns for MCP servers. Auto-loads when building MCP servers, creating tools/resources/prompts, implementing authentication, configuring transports, or working with FastMCP in TypeScript.

add-mcp-tool

9
from jpoutrin/product-forge

Add a new tool to an existing FastMCP server with guided configuration

add-mcp-resource

9
from jpoutrin/product-forge

Add a new resource or resource template to an existing FastMCP server

plan-with-team

9
from jpoutrin/product-forge

Validate plan file ownership

privacy-compliance

9
from jpoutrin/product-forge

GDPR, CCPA, and privacy compliance guidance for data protection. Use when handling personal data, implementing consent management, or ensuring regulatory compliance across jurisdictions.

oauth

9
from jpoutrin/product-forge

OAuth 2.0 and OpenID Connect implementation patterns. Use when implementing authentication, authorization flows, or integrating with OAuth providers like Google, GitHub, or custom identity providers.

mcp-security

9
from jpoutrin/product-forge

Use when securing MCP servers, preventing prompt injection, implementing authorization, validating user input, or building secure multi-agent pipelines. Provides 5-layer defense architecture patterns.

rag-cag-security

9
from jpoutrin/product-forge

Security patterns for RAG and CAG systems with multi-tenant isolation. Use when building retrieval-augmented or cache-augmented generation systems that require tenant isolation, access control, and secure data handling.

chunking-strategies

9
from jpoutrin/product-forge

Document chunking strategies for RAG systems. Use when implementing document processing pipelines to determine optimal chunking approaches based on document type and retrieval requirements.