Sztuczki wydajności

Zmaksymalizuj swoją produktywność z Claude Code poprzez sprytne skróty, sztuczki automatyzacji i wzorce oszczędzające czas. Ten przewodnik ujawnia techniki power-użytkowników, które mogą dramatycznie przyspieszyć Twój przepływ pracy programistycznej.

Techniki szybkich wygranych

Skróty szybkości

Natychmiastowe polecenia

# Utwórz aliasy dla częstych operacji
alias ccode='claude'
alias ccreview='claude review'
alias cctest='claude "Wygeneruj testy dla"'
alias ccdoc='claude "Udokumentuj"'
alias ccfix='claude "Napraw błąd:"'

Biblioteka szablonów

# Buduj szablony promptów wielokrotnego użytku
echo 'Refaktoryzuj dla wydajności' > ~/.claude-templates/perf
echo 'Dodaj obsługę błędów' > ~/.claude-templates/errors
echo 'Wygeneruj REST API' > ~/.claude-templates/api

# Używaj szablonów
ccode "$(cat ~/.claude-templates/perf) $1"

Produktywność linii poleceń

Przetwarzanie wsadowe

Równoległe przetwarzanie plików

# Przetwarzaj wiele plików równolegle
find . -name "*.js" -type f | \
  parallel -j 4 "claude 'Dodaj komentarze JSDoc do {}' --edit"

# Refaktoryzacja wsadowa z postępem
ls src/**/*.ts | pv -l | \
  xargs -P 4 -I {} claude "Zmodernizuj TypeScript w {}" --edit

Inteligentny wybór plików

# Przetwarzaj tylko zmienione pliki
git diff --name-only main | \
  grep -E '\.(js|ts)$' | \
  xargs -I {} claude "Przejrzyj i ulepsz {}"

# Skup się na złożonych plikach
find . -name "*.js" -exec wc -l {} + | \
  sort -rn | head -20 | awk '{print $2}' | \
  xargs -I {} claude "Uprość złożony kod w {}"

Przetwarzanie warunkowe

# Przetwarzaj tylko pliki z TODO
grep -l "TODO" src/**/*.js | \
  xargs -I {} claude "Zaimplementuj TODO w {}" --edit

# Napraw pliki z błędami lintingu
eslint . --format json | \
  jq -r '.[] | select(.errorCount > 0) | .filePath' | \
  xargs -I {} claude "Napraw błędy ESLint w {}" --edit

Funkcje powłoki

Potężne funkcje

# Dodaj do ~/.bashrc lub ~/.zshrc

# Szybki code review dla aktualnej gałęzi
ccreview-branch() {
  local base="${1:-main}"
  git diff "$base"...HEAD --name-only | \
    xargs -I {} claude review {} --format summary
}

# Generuj testy dla zmodyfikowanych funkcji
cctest-changed() {
  git diff --name-only | \
    xargs -I {} claude "Wygeneruj testy dla zmienionych funkcji w {}" \
    --output "{}.test.${{}##*.}"
}

# Natychmiastowa dokumentacja
ccdoc-func() {
  local file="$1"
  local line="$2"
  claude "Udokumentuj funkcję w linii $line w $file" --edit
}

# Napraw i formatuj
ccfix-format() {
  claude "Napraw błędy i formatuj kod w $1" --edit && \
  prettier --write "$1" && \
  eslint --fix "$1"
}

# Wyjaśnij złożony kod
ccexplain() {
  local file="$1"
  local start="$2"
  local end="${3:-$((start+20))}"
  sed -n "${start},${end}p" "$file" | \
    claude "Wyjaśnij ten kod w prostych słowach"
}

# Analiza wydajności
ccperf() {
  claude "Przeanalizuj wąskie gardła wydajności w $1 i zasugeruj optymalizacje"
}

# Audyt bezpieczeństwa
ccsecurity() {
  claude "Audituj $1 pod kątem luk bezpieczeństwa i zasugeruj poprawki"
}

Sztuczki integracji IDE

{
  "Claude Review": {
    "prefix": "ccrev",
    "body": [
      "!claude review ${TM_FILENAME} --focus '${1:security,performance}'"
    ],
    "description": "Przejrzyj aktualny plik z Claude"
  },
  "Claude Test": {
    "prefix": "cctest",
    "body": [
      "!claude 'Wygeneruj kompleksowe testy dla ${TM_FILENAME}' --output ${TM_FILENAME_BASE}.test.${TM_FILENAME_EXT}"
    ],
    "description": "Wygeneruj testy dla aktualnego pliku"
  },
  "Claude Refactor": {
    "prefix": "ccref",
    "body": [
      "!claude 'Refaktoryzuj ${1:funkcję} w ${TM_FILENAME} dla ${2:clarity and performance}' --edit"
    ],
    "description": "Refaktoryzuj z Claude"
  },
  "Claude Implement": {
    "prefix": "ccimp",
    "body": [
      "// TODO: Zaimplementuj ${1:feature}",
      "!claude 'Zaimplementuj TODO powyżej w ${TM_FILENAME}' --edit"
    ],
    "description": "Zaimplementuj TODO z Claude"
  }
}

{
  "version": "2.0.0",
  "tasks": [
    {
      "label": "Claude: Quick Fix",
      "type": "shell",
      "command": "claude",
      "args": [
        "'Napraw błąd w linii ${lineNumber} w ${file}'",
        "--edit"
      ],
      "problemMatcher": [],
      "presentation": {
        "reveal": "silent"
      }
    },
    {
      "label": "Claude: Optimize Function",
      "type": "shell",
      "command": "claude",
      "args": [
        "'Zoptymalizuj funkcję w linii ${lineNumber} w ${file} dla wydajności'",
        "--edit"
      ]
    },
    {
      "label": "Claude: Add Types",
      "type": "shell",
      "command": "claude",
      "args": [
        "'Dodaj typy TypeScript do ${file}'",
        "--edit"
      ]
    }
  ]
}

Skróty klawiszowe

Keybindings VS Code

[
  {
    "key": "ctrl+alt+r",
    "command": "workbench.action.terminal.sendSequence",
    "args": {
      "text": "claude review '${file}' --format summary\n"
    }
  },
  {
    "key": "ctrl+alt+t",
    "command": "workbench.action.terminal.sendSequence",
    "args": {
      "text": "claude 'Wygeneruj testy dla ${file}' --output '${fileDirname}/__tests__/${fileBasename}'\n"
    }
  },
  {
    "key": "ctrl+alt+f",
    "command": "workbench.action.terminal.sendSequence",
    "args": {
      "text": "claude 'Napraw błędy lintingu w ${file}' --edit\n"
    }
  },
  {
    "key": "ctrl+alt+d",
    "command": "workbench.action.terminal.sendSequence",
    "args": {
      "text": "claude 'Dodaj kompleksową dokumentację do ${file}' --edit\n"
    }
  }
]

Skrypty automatyzacji

Automatyzacja codziennego przepływu pracy

Skrypt uruchomienia porannego

#!/bin/bash
echo "🌅 Dzień dobry! Rozpoczynam codzienny przepływ pracy..."

# Aktualizuj zależności i sprawdź problemy
echo "📦 Sprawdzanie zależności..."
npm outdated | claude "Przeanalizuj przestarzałe pakiety i zasugeruj strategię aktualizacji"

# Przejrzyj wczorajsze TODO
echo "📝 Przeglądanie TODO..."
git log --since="yesterday" --grep="TODO" --oneline | \
  claude "Podsumuj wczorajsze TODO i zasugeruj priorytety"

# Sprawdź nocne niepowodzenia CI
echo "🔍 Sprawdzanie statusu CI..."
gh run list --limit 10 --json conclusion,name | \
  claude "Przeanalizuj niepowodzenia CI i zasugeruj poprawki"

# Wygeneruj plan dzienny
echo "📅 Tworzenie planu dziennego..."
claude "Na podstawie powyższych informacji, utwórz priorytetową listę zadań na dzisiaj"

Monitor jakości kodu

#!/bin/bash
# Uruchom w tle przez cały dzień
while true; do
  # Sprawdź zapachy kodu w ostatnio zmodyfikowanych plikach
  git diff --name-only HEAD~5..HEAD | \
    xargs -I {} claude "Szybkie sprawdzenie zapachów kodu w {}" \
    --format json > quality-report.json

  # Alertuj jeśli znaleziono problemy
  if jq -e '.issues | length > 0' quality-report.json > /dev/null; then
    notify-send "Alert jakości kodu" "Znaleziono problemy w ostatnich zmianach"
  fi

  sleep 3600  # Sprawdzaj co godzinę
done

Inteligentne hooki Git

#!/bin/bash
# Auto-generuj komunikaty commitów
COMMIT_MSG_FILE=$1
COMMIT_SOURCE=$2

if [ -z "$COMMIT_SOURCE" ]; then
  # Pobierz staged changes
  CHANGES=$(git diff --cached --name-status)

  # Wygeneruj komunikat commita
  GENERATED_MSG=$(echo "$CHANGES" | \
    claude "Wygeneruj konwencjonalny komunikat commita dla tych zmian. Bądź zwięzły.")

  # Dodaj na początek pliku komunikatu commita
  echo "$GENERATED_MSG" > "$COMMIT_MSG_FILE.tmp"
  echo "" >> "$COMMIT_MSG_FILE.tmp"
  echo "# Wygenerowany przez Claude Code. Edytuj w razie potrzeby." >> "$COMMIT_MSG_FILE.tmp"
  cat "$COMMIT_MSG_FILE" >> "$COMMIT_MSG_FILE.tmp"
  mv "$COMMIT_MSG_FILE.tmp" "$COMMIT_MSG_FILE"
fi

# .git/hooks/post-merge
#!/bin/bash
# Auto-obsługa konfliktów merge

if [ -f .git/MERGE_HEAD ]; then
  # Znajdź pliki z konfliktami
  CONFLICTED=$(git diff --name-only --diff-filter=U)

  if [ -n "$CONFLICTED" ]; then
    echo "🤖 Claude Code analizuje konflikty merge..."

    for file in $CONFLICTED; do
      claude "Rozwiąż konflikty merge w $file inteligentnie, zachowując obie zmiany gdzie to możliwe" \
        --edit
    done

    echo "✅ Konflikty rozwiązane. Proszę przejrzeć zmiany."
  fi
fi

Optymalizacja kontekstu

Inteligentne budowanie kontekstu

Finder odpowiednich plików

#!/usr/bin/env python3
import os
import ast
import networkx as nx
from pathlib import Path

def build_dependency_graph(root_dir):
    """Buduj graf zależności plików"""
    graph = nx.DiGraph()

    for path in Path(root_dir).rglob("*.py"):
        graph.add_node(str(path))

        try:
            with open(path) as f:
                tree = ast.parse(f.read())

            for node in ast.walk(tree):
                if isinstance(node, ast.Import):
                    for alias in node.names:
                        dep_path = find_file(alias.name, root_dir)
                        if dep_path:
                            graph.add_edge(str(path), dep_path)

        except:
            pass

    return graph

def find_related_files(target_file, graph, max_depth=2):
    """Znajdź pliki powiązane z celem w max_depth"""
    related = set()

    # Znajdź zależności i dependentów
    if target_file in graph:
        # Bezpośrednie zależności
        related.update(graph.successors(target_file))

        # Bezpośredni dependenci
        related.update(graph.predecessors(target_file))

        # Relacje N-tego stopnia
        for _ in range(max_depth - 1):
            new_related = set()
            for file in related:
                new_related.update(graph.successors(file))
                new_related.update(graph.predecessors(file))
            related.update(new_related)

    return list(related)[:10]  # Ogranicz do 10 najważniejszych

# Użyj w Claude Code
if __name__ == "__main__":
    import sys
    target = sys.argv[1]

    graph = build_dependency_graph(".")
    related = find_related_files(target, graph)

    # Buduj polecenie Claude z kontekstem
    cmd = f"claude 'Przeanalizuj {target}' --context {target}"
    for file in related:
        cmd += f" --context {file}"

    print(cmd)
    os.system(cmd)

Semantyczne chunki

#!/bin/bash
# Podziel duże pliki na semantyczne chunki
chunk_file() {
  local file="$1"
  local chunk_size=50

  # Wyciągnij funkcje/klasy jako chunki
  grep -n "^def \|^class " "$file" | while read -r line; do
    line_num=$(echo "$line" | cut -d: -f1)
    func_name=$(echo "$line" | cut -d' ' -f2)

    # Wyciągnij funkcję z kontekstem
    sed -n "$((line_num-5)),$((line_num+chunk_size))p" "$file" > "/tmp/chunk_${func_name}.py"
  done
}

# Użyj chunków do skoncentrowanej analizy
analyze_with_chunks() {
  local file="$1"
  local query="$2"

  chunk_file "$file"

  # Znajdź odpowiednie chunki
  relevant_chunks=$(ls /tmp/chunk_*.py | \
    xargs -I {} sh -c "grep -l '$query' {} || true")

  if [ -n "$relevant_chunks" ]; then
    claude "Przeanalizuj w kontekście '$query'" \
      $(echo $relevant_chunks | xargs -n1 echo "--context")
  else
    claude "Przeanalizuj $file w kontekście '$query'"
  fi

  # Sprzątanie
  rm -f /tmp/chunk_*.py
}

Optymalizacja wydajności

Optymalizacja użycia tokenów

Kompresuj prompty

import re
import tiktoken

class PromptCompressor:
    def __init__(self):
        self.encoder = tiktoken.get_encoding("cl100k_base")

    def compress(self, prompt):
        """Kompresuj prompt zachowując znaczenie"""
        # Usuń nadmiarowe białe znaki
        prompt = re.sub(r'\s+', ' ', prompt)

        # Użyj skrótów
        abbreviations = {
            'function': 'func',
            'variable': 'var',
            'parameter': 'param',
            'return': 'ret',
            'implement': 'impl',
            'documentation': 'docs',
            'configuration': 'config'
        }

        for long, short in abbreviations.items():
            prompt = prompt.replace(long, short)

        # Usuń słowa wypełniające
        fillers = ['proszę', 'czy możesz', 'chciałbym', 'czy możesz']
        for filler in fillers:
            prompt = prompt.replace(filler, '')

        return prompt.strip()

    def estimate_tokens(self, text):
        """Oszacuj liczbę tokenów"""
        return len(self.encoder.encode(text))

    def optimize_context(self, files, max_tokens=3000):
        """Optymalizuj kontekst plików aby zmieścić się w limicie tokenów"""
        context_parts = []
        current_tokens = 0

        for file_path, content in files.items():
            # Pobierz ważne części
            important = self.extract_important(content)
            tokens = self.estimate_tokens(important)

            if current_tokens + tokens <= max_tokens:
                context_parts.append(f"# {file_path}\n{important}")
                current_tokens += tokens
            else:
                # Dodaj tylko podsumowanie
                summary = self.summarize(content)
                context_parts.append(f"# {file_path} (podsumowanie)\n{summary}")
                current_tokens += self.estimate_tokens(summary)

        return "\n\n".join(context_parts)

Buforowanie odpowiedzi

# Utwórz katalog cache
CACHE_DIR="$HOME/.claude-cache"
mkdir -p "$CACHE_DIR"

# Funkcja Claude Code z cache
ccache() {
  local prompt="$1"
  shift

  # Wygeneruj klucz cache
  cache_key=$(echo "$prompt $@" | sha256sum | cut -d' ' -f1)
  cache_file="$CACHE_DIR/$cache_key"

  # Sprawdź cache
  if [ -f "$cache_file" ] && [ -z "$CLAUDE_NO_CACHE" ]; then
    echo "📦 Używam cache odpowiedzi..."
    cat "$cache_file"
  else
    # Uruchom Claude Code i zapisz w cache
    claude "$prompt" "$@" | tee "$cache_file"
  fi
}

# Czyszczenie cache (uruchamiaj codziennie)
cleanup_cache() {
  find "$CACHE_DIR" -type f -mtime +7 -delete
  echo "🧹 Wyczyszczono stare wpisy cache"
}

Zaawansowane przepływy pracy

Przetwarzanie wieloetapowe

Przetwarzanie potokowe

#!/bin/bash
# Przetwarzaj kod przez wiele etapów
process_pipeline() {
  local input_file="$1"
  local temp_dir=$(mktemp -d)

  # Etap 1: Analiza
  echo "🔍 Etap 1: Analiza"
  claude "Przeanalizuj $input_file pod kątem problemów" \
    --output "$temp_dir/analysis.md"

  # Etap 2: Planowanie
  echo "📋 Etap 2: Planowanie"
  claude "Na podstawie analizy, utwórz plan refaktoryzacji" \
    --input "$temp_dir/analysis.md" \
    --output "$temp_dir/plan.md"

  # Etap 3: Implementacja
  echo "🔨 Etap 3: Implementacja"
  claude "Zaimplementuj plan refaktoryzacji" \
    --input "$temp_dir/plan.md" \
    --context "$input_file" \
    --output "$temp_dir/refactored.js"

  # Etap 4: Weryfikacja
  echo "✅ Etap 4: Weryfikacja"
  claude "Porównaj oryginalne i refaktoryzowane wersje, upewnij się że funkcjonalność zachowana" \
    --context "$input_file" \
    --context "$temp_dir/refactored.js" \
    --output "$temp_dir/verification.md"

  # Pokaż wyniki
  echo "📊 Wyniki potoku:"
  cat "$temp_dir/verification.md"

  # Opcjonalnie: Zastosuj zmiany
  read -p "Zastosować zmiany? (y/n) " -n 1 -r
  echo
  if [[ $REPLY =~ ^[Yy]$ ]]; then
    cp "$temp_dir/refactored.js" "$input_file"
    echo "✅ Zmiany zastosowane"
  fi

  # Sprzątanie
  rm -rf "$temp_dir"
}

Inteligentne grupowanie

from collections import defaultdict
import subprocess

def group_files_by_pattern(files):
    """Grupuj pliki według podobnych wzorców"""
    groups = defaultdict(list)

    for file in files:
        # Grupuj wg katalogu
        dir_key = os.path.dirname(file)
        groups[f"dir:{dir_key}"].append(file)

        # Grupuj wg typu pliku
        ext = os.path.splitext(file)[1]
        groups[f"ext:{ext}"].append(file)

        # Grupuj wg prefiksu
        prefix = os.path.basename(file).split('_')[0]
        groups[f"prefix:{prefix}"].append(file)

    return groups

def batch_process_groups(groups, command_template):
    """Przetwarzaj grupy efektywnie"""
    for group_key, files in groups.items():
        if len(files) > 1:
            # Przetwarzaj podobne pliki wsadowo
            print(f"Przetwarzanie {group_key} ({len(files)} plików)")

            file_list = ' '.join(files)
            cmd = command_template.format(files=file_list)

            subprocess.run(cmd, shell=True)
        else:
            # Przetwarzaj pojedynczy plik
            subprocess.run(
                command_template.format(files=files[0]),
                shell=True
            )

Kolejka priorytetów

import heapq
from datetime import datetime

class PriorityProcessor:
    def __init__(self):
        self.queue = []

    def add_task(self, priority, task):
        # Niższy numer = wyższy priorytet
        heapq.heappush(self.queue, (priority, datetime.now(), task))

    def process_next(self):
        if self.queue:
            priority, timestamp, task = heapq.heappop(self.queue)
            return task
        return None

    def batch_add_from_analysis(self, analysis_file):
        """Dodaj zadania na podstawie analizy kodu"""
        with open(analysis_file) as f:
            analysis = json.load(f)

        for issue in analysis['issues']:
            if issue['severity'] == 'error':
                priority = 1
            elif issue['severity'] == 'warning':
                priority = 5
            else:
                priority = 10

            task = {
                'file': issue['file'],
                'line': issue['line'],
                'fix': issue['suggested_fix'],
                'command': f"claude 'Napraw: {issue['message']}' --edit"
            }

            self.add_task(priority, task)

Monitorowanie i metryki

Analityka użycia

Dashboard produktywności osobistej

#!/usr/bin/env python3
import sqlite3
import json
from datetime import datetime, timedelta
import matplotlib.pyplot as plt

class ClaudeAnalytics:
    def __init__(self, db_path="~/.claude-analytics.db"):
        self.conn = sqlite3.connect(os.path.expanduser(db_path))
        self.init_db()

    def init_db(self):
        self.conn.execute("""
            CREATE TABLE IF NOT EXISTS usage (
                id INTEGER PRIMARY KEY,
                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
                command TEXT,
                tokens_used INTEGER,
                execution_time REAL,
                file_type TEXT,
                operation_type TEXT
            )
        """)

    def log_usage(self, command, tokens, exec_time):
        """Loguj użycie Claude Code"""
        # Wyciągnij typ operacji
        op_type = 'inne'
        if 'review' in command:
            op_type = 'przegląd'
        elif 'test' in command:
            op_type = 'test'
        elif 'refactor' in command:
            op_type = 'refaktoryzacja'
        elif 'document' in command:
            op_type = 'dokumentacja'

        self.conn.execute("""
            INSERT INTO usage (command, tokens_used, execution_time, operation_type)
            VALUES (?, ?, ?, ?)
        """, (command, tokens, exec_time, op_type))
        self.conn.commit()

    def generate_report(self):
        """Wygeneruj raport produktywności"""
        # Użycie z ostatnich 7 dni
        week_ago = datetime.now() - timedelta(days=7)

        cursor = self.conn.execute("""
            SELECT
                DATE(timestamp) as date,
                COUNT(*) as operations,
                SUM(tokens_used) as total_tokens,
                AVG(execution_time) as avg_time,
                operation_type
            FROM usage
            WHERE timestamp > ?
            GROUP BY DATE(timestamp), operation_type
            ORDER BY date DESC
        """, (week_ago,))

        data = cursor.fetchall()

        # Utwórz wizualizacje
        self.plot_usage_trends(data)
        self.plot_operation_distribution(data)

        # Oblicz insights
        total_ops = sum(row[1] for row in data)
        total_tokens = sum(row[2] for row in data)
        time_saved = total_ops * 10  # Załóż 10 min oszczędzone na operację

        print(f"""
        📊 Raport produktywności Claude Code
        ====================================

        Ostatnie 7 dni:
        - Łączne operacje: {total_ops}
        - Użyte tokeny: {total_tokens:,}
        - Szacowany oszczędzony czas: {time_saved} minut
        - Najczęstsza operacja: {self.most_common_op(data)}

        Średnia dzienna:
        - Operacje: {total_ops / 7:.1f}
        - Tokeny: {total_tokens / 7:,.0f}

        💡 Wskazówki produktywności:
        {self.generate_tips(data)}
        """)

    def generate_tips(self, data):
        """Wygeneruj spersonalizowane wskazówki produktywności"""
        tips = []

        # Analizuj wzorce
        op_counts = defaultdict(int)
        for row in data:
            op_counts[row[4]] += row[1]

        if op_counts['przegląd'] < op_counts['test']:
            tips.append("- Rozważ więcej przeglądów kodu aby wcześnie wyłapać problemy")

        if op_counts['dokumentacja'] < total_ops * 0.1:
            tips.append("- Zwiększ generowanie dokumentacji dla lepszej maintainability")

        return '\n'.join(tips) if tips else "- Kontynuuj świetną pracę!"

# Wrapper dla Claude Code z analityką
def claude_with_analytics():
    analytics = ClaudeAnalytics()

    # Owij polecenie Claude Code
    import sys
    import time

    start_time = time.time()

    # Uruchom rzeczywiste polecenie
    os.system(f"claude {' '.join(sys.argv[1:])}")

    # Loguj użycie
    exec_time = time.time() - start_time
    command = ' '.join(sys.argv[1:])
    tokens = estimate_tokens(command)  # Implementuj oszacowanie tokenów

    analytics.log_usage(command, tokens, exec_time)

if __name__ == "__main__":
    if "--report" in sys.argv:
        ClaudeAnalytics().generate_report()
    else:
        claude_with_analytics()

Najlepsze praktyki

Karta szybkiego odniesienia

Podstawowe skróty

# Najużyteczniejsze aliasy
alias cc='claude'
alias ccr='claude review'
alias cct='claude "Wygeneruj testy dla"'
alias ccd='claude "Udokumentuj"'
alias ccf='claude "Napraw"'

# Szybkie funkcje
ccfunc() { claude "Wyjaśnij funkcję w linii $2 w $1"; }
ccopt() { claude "Zoptymalizuj $1 dla wydajności"; }
ccsec() { claude "Audyt bezpieczeństwa $1"; }

# Operacje wsadowe
ccall() { find . -name "*.js" | xargs -P 4 -I {} claude "$1 {}" --edit; }
ccchanged() { git diff --name-only | xargs -I {} claude "$1 {}"; }

# Helpery kontekstu
ccwith() { claude "$1" --context "$2" --context "$3"; }
ccproject() { claude "$1" --context "$(find . -name '*.md' | head -5)"; }

Następne kroki

Kontynuuj opanowywanie Claude Code:

Mistrzostwo terminala dla zaawansowanych technik CLI
Automatyzacja skryptów dla złożonych przepływów
Operacje wsadowe dla zmian na dużą skalę

Pamiętaj: Najlepsza sztuczka wydajności to zrozumienie własnego przepływu pracy. Śledź co robisz najczęściej i optymalizuj najpierw te konkretne zadania. Małe oszczędności czasu na częstych operacjach sumują się do masywnych zysków produktywności.