Basic Workflow Skill

Production-Grade Learning Skill | Version 2.0.0

Master the daily rhythm of Git operations.

Skill Contract

Input Schema

input:
  type: object
  properties:
    workflow_type:
      type: string
      enum: [solo, feature-branch, quick-fix, team]
      default: solo
    current_state:
      type: object
      properties:
        has_remote:
          type: boolean
        has_uncommitted:
          type: boolean
        current_branch:
          type: string
    include_push:
      type: boolean
      default: true
  validation:
    auto_detect_state: true

Output Schema

output:
  type: object
  required: [workflow_steps, success]
  properties:
    workflow_steps:
      type: array
      items:
        type: object
        properties:
          step: integer
          command: string
          description: string
          safe: boolean
    success:
      type: boolean
    warnings:
      type: array
      items:
        type: string
    diagram:
      type: string

Error Handling

Retry Logic

retry_config:
  max_attempts: 3
  backoff_type: exponential
  initial_delay_ms: 1000
  max_delay_ms: 8000
  retryable:
    - network_timeout
    - remote_connection_failed

Fallback Strategy

fallback:
  - trigger: push_rejected
    action: suggest_pull_first
  - trigger: merge_conflict
    action: guide_conflict_resolution
  - trigger: authentication_failed
    action: check_credentials

The Daily Cycle

┌──────────────────────────────────────────────────────────────┐
│                    DAILY GIT WORKFLOW                        │
├──────────────────────────────────────────────────────────────┤
│                                                              │
│   Morning:  git pull        ← Get latest from team          │
│             │                                                │
│             ▼                                                │
│   Work:     (make changes)  ← Do your development           │
│             │                                                │
│             ▼                                                │
│   Check:    git status      ← See what changed              │
│             │                                                │
│             ▼                                                │
│   Stage:    git add         ← Prepare for saving            │
│             │                                                │
│             ▼                                                │
│   Save:     git commit      ← Save your work                │
│             │                                                │
│             ▼                                                │
│   Share:    git push        ← Share with team               │
│                                                              │
└──────────────────────────────────────────────────────────────┘

Essential Commands

1. Start Your Day:

git pull

# Get the latest changes from remote
git pull origin main

# What it does:
# 1. Fetches changes from remote
# 2. Merges them into your branch

2. Check Status:

git status

git status

# Output explains:
# - Modified files (red = not staged)
# - Staged files (green = ready to commit)
# - Untracked files (new files)

3. View Changes:

git diff

# See unstaged changes
git diff

# See staged changes
git diff --staged

# See changes for specific file
git diff README.md

4. Stage Changes:

git add

# Add specific file
git add README.md

# Add multiple files
git add file1.js file2.js

# Add all files in directory
git add src/

# Add all changes (use carefully!)
git add .

# Interactive staging
git add -p  # Review each change

5. Commit Changes:

git commit

# Commit with inline message
git commit -m "Add user authentication"

# Commit with detailed message (opens editor)
git commit

# Add and commit in one step (tracked files only)
git commit -am "Quick fix for typo"

6. Share Your Work:

git push

# Push to remote
git push origin main

# First push of a new branch
git push -u origin feature-branch

Workflow Patterns

Pattern 1: Solo Work

# Start of day
git pull

# Throughout day
git status
git add .
git commit -m "Feature: Add login form"
git push

Pattern 2: Feature Development

# Create feature branch
git checkout -b feature/user-settings

# Work and commit multiple times
git add src/settings.js
git commit -m "Add settings page structure"

git add src/settings.css
git commit -m "Style settings page"

# Push branch
git push -u origin feature/user-settings

Pattern 3: Quick Fix

git checkout main
git pull
git add fix.js
git commit -m "Fix: Button alignment on mobile"
git push

The Perfect Commit

What Makes a Good Commit?

Commit Message Format

type: subject line (50 chars max)

body: detailed explanation (optional)
- what you did
- why you did it
- any side effects

Closes #123  (optional: reference issues)

Types

• feat:

  New feature

• fix:

  Bug fix

• docs:

  Documentation only

• style:

  Formatting (no code change)

• refactor:

  Code restructure

• test:

  Adding tests

• chore:

  Maintenance

Common Scenarios

Scenario 1: "Oops, wrong file!"

# Remove from staging (keep file)
git restore --staged accidental-file.txt

# Or the older syntax
git reset HEAD accidental-file.txt

Scenario 2: "I want to undo my changes"

# Undo changes in working directory (DESTRUCTIVE!)
git restore file.txt

# Or restore all files
git restore .

Scenario 3: "I forgot to add a file to last commit"

git add forgotten-file.txt
git commit --amend --no-edit
# Note: Only do this BEFORE pushing!

Scenario 4: "I need to see what I did yesterday"

git log --oneline --since="yesterday"
git log --oneline -10  # Last 10 commits
git log --oneline --author="Your Name"

Quick Reference Card

┌─────────────────────────────────────────────────────────┐
│              DAILY WORKFLOW CHEATSHEET                  │
├─────────────────────────────────────────────────────────┤
│                                                         │
│  START DAY         git pull                             │
│                                                         │
│  CHECK WORK        git status                           │
│                    git diff                             │
│                                                         │
│  SAVE WORK         git add <files>                      │
│                    git commit -m "message"              │
│                                                         │
│  SHARE WORK        git push                             │
│                                                         │
│  VIEW HISTORY      git log --oneline                    │
│                                                         │
│  UNDO STAGING      git restore --staged <file>          │
│                                                         │
│  UNDO CHANGES      git restore <file>                   │
│                                                         │
└─────────────────────────────────────────────────────────┘

Troubleshooting Guide

Debug Checklist

□ 1. Remote configured? → git remote -v
□ 2. Upstream set? → git branch -vv
□ 3. Clean working tree? → git status
□ 4. Authentication ok? → git fetch (test)

Common Issues

git pull

Log Patterns

# Successful push
To github.com:user/repo.git
   abc1234..def5678  main -> main

# Rejected push (need pull)
! [rejected]        main -> main (non-fast-forward)
hint: Updates were rejected...

Unit Test Template

#!/bin/bash
# test_workflow.sh

test_pull_updates_local() {
  # Setup: create remote with commit
  # Action: git pull
  # Assert: local has new commit
}

test_push_sends_changes() {
  # Setup: create local commit
  # Action: git push
  # Assert: remote has new commit
}

test_status_shows_changes() {
  # Setup: modify file
  # Action: git status
  # Assert: file shown as modified
}

Observability

logging:
  level: INFO
  events:
    - workflow_started
    - pull_completed
    - changes_staged
    - commit_created
    - push_completed
    - error_occurred

metrics:
  - commits_per_day
  - push_frequency
  - conflict_rate
  - workflow_completion_rate

Avoiding Common Mistakes

.gitignore

Next Steps

After mastering basic workflow:

1. branching - Work on features in isolation
2. collaboration - Work with team members
3. advanced-git - Power user operations

"Consistent workflow leads to reliable code history."