Refactor README to clarify project purpose and workflow

Update project description, positioning, and documentation to better articulate the unique value proposition of poorcoder as a lightweight AI coding assistant toolkit

Author: vgrichina

README.md

@@ -1,22 +1,31 @@
-# Minimalistic AI Coding Assistant
+# poorcoder
 
-A collection of lightweight Bash scripts to enhance your coding workflow with AI assistance. These tools integrate seamlessly with your terminal workflow, allowing you to leverage AI models without disrupting your development process.
+A collection of lightweight Bash scripts to enhance your coding workflow with AI assistance. These tools bridge the gap between web-based AI interfaces and your terminal, allowing you to leverage subscription-based LLMs (like Claude.ai or Grok) without disrupting your development process.
 
 ## Overview
 
 This repository contains three main tools:
 
-1. **`context`** - Extracts code context to send to an LLM
+1. **`context`** - Extracts code context from your project to send to an LLM
 2. **`apply-md`** - Applies code changes from LLM's markdown response
 3. **`git-context`** - Generates git context for AI-assisted commit messages
 
+## Why poorcoder?
+
+Unlike IDE-integrated solutions (Cursor, aider, Claude Code, etc.), poorcoder is designed to work with your existing web-based LLM subscriptions (~$20/month) while maintaining your terminal workflow. This approach:
+
+- Is more cost-effective than dedicated API usage
+- Leverages the polished UX of web/mobile LLM interfaces
+- Preserves your terminal-based development workflow
+- Follows Unix philosophy (small tools doing one thing well)
+
 ## Installation
 
 Simply clone this repository and make the scripts executable:
 
 ```bash
-git clone https://github.com/yourusername/ai-coding-assistant.git
-cd ai-coding-assistant
+git clone https://github.com/vgrichina/poorcoder.git
+cd poorcoder
 chmod +x context apply-md git-context
 ```
 
@@ -26,27 +35,31 @@ You can either use the scripts directly from this folder or add them to your PAT
 
 ### 1. `context` - Code Context Generator
 
-Generates contextual information from a codebase to send to an LLM.
+Extracts relevant code context from your project to send to a web-based LLM.
 
 ```bash
-# Using file patterns
-./context --include="src/*.js" --exclude="*.test.js" > context.md
+# Copy context directly to clipboard (macOS)
+./context --include="src/*.js" --exclude="*.test.js" | pbcopy
 
 # Using direct patterns as arguments
-./context "src/*.js" "README.md" > context.md
+./context "src/*.js" "README.md" | pbcopy
 
 # Including git information
-./context --include="src/*.js" --git > context.md
+./context --include="src/*.js" --git | pbcopy
 ```
 
 [See full documentation for context](./docs/context.md)
 
 ### 2. `apply-md` - Markdown Code Applier
 
-Extracts code blocks from markdown and applies changes to your filesystem.
+Extracts code blocks from markdown (typically LLM responses) and applies changes to your filesystem.
 
 ```bash
-cat llm_response.md | ./apply-md --dry-run --verbose
+# Paste LLM response from clipboard (macOS)
+pbpaste | ./apply-md --dry-run --verbose
+
+# Apply changes and create missing files
+pbpaste | ./apply-md --create-missing
 ```
 
 [See full documentation for apply-md](./docs/apply-md.md)
@@ -56,105 +69,72 @@ cat llm_response.md | ./apply-md --dry-run --verbose
 Generates git-related context to help LLMs create meaningful commit messages.
 
 ```bash
-./git-context --recent-commits=5 --prompt=prompts/conventional_commit.txt > commit_context.txt
+# Generate context, then use with API-based LLM via CLI tool
+git commit -am "$(./git-context | llm -m openrouter/anthropic/claude-3.5-haiku)" -e
 ```
 
 [See full documentation for git-context](./docs/git-context.md)
 
 ## Usage Workflows
 
-### Unix-style Pipelines
+### Dual Modality Approach
 
-These tools are designed to work seamlessly in Unix pipelines, allowing you to create powerful workflows with minimal effort:
+poorcoder supports two primary workflows:
+
+#### 1. Web UI LLM + Terminal
+
+Ideal for complex interactions and leveraging your LLM subscription:
 
 ```bash
-# Copy code context directly to clipboard (macOS)
-./context --include="src/api/*.js" | pbcopy
+# 1. Generate context and copy to clipboard
+./context --include="src/components/*.js" | pbcopy
 
-# Generate and apply code changes directly from clipboard (macOS)
-pbpaste | ./apply-md
+# 2. Paste into web UI (Claude.ai, Grok, etc.), ask for changes
+
+# 3. Copy response and apply changes
+pbpaste | ./apply-md --create-missing
+```
 
-# Auto-generate commit message using an LLM CLI tool
+#### 2. All-Terminal with CLI LLM
+
+For quick operations or automation using LLM CLI tools:
+
+```bash
+# Generate commit message using LLM CLI
 git commit -am "$(./git-context | llm -m openrouter/anthropic/claude-3.5-haiku)" -e
 
-# Stream context to an LLM and apply changes in one command
-./context --include="src/components/Button.js" | llm "Refactor this component to use hooks" | ./apply-md
+# Fix a small issue directly in terminal
+./context --include="src/buggy-file.js" | llm "Fix the null reference bug" | ./apply-md
 ```
 
-### Scenario: Bug Fix Workflow
-
-Let's walk through a complete workflow for fixing a bug:
+### Scenario: Bug Fix in a Complex Project
 
-1. Identify the files involved in the bug:
+1. Gather relevant context:
    ```bash
-   # Generate context for the relevant files
    ./context --include="src/utils/validation.js" --include="src/components/Form.js" | pbcopy
    ```
 
-2. Paste the context into your preferred AI assistant's web UI with your request:
-   "There's a bug where form validation fails when empty strings are submitted. Please fix it."
+2. Paste into Claude.ai or Grok with your request:
+   "There's a bug where form validation fails when empty strings are submitted. Fix it while maintaining our validation approach."
 
-3. Copy the AI's response and apply the suggested changes:
+3. Copy the AI's response and apply changes:
    ```bash
    pbpaste | ./apply-md --dry-run  # Preview changes
    pbpaste | ./apply-md            # Apply changes
    ```
 
-4. Generate an appropriate commit message:
+4. Generate a commit message:
    ```bash
-   # Auto-generate semantically meaningful commit message
-   ./git-context | llm "Generate a conventional commit message" | git commit -F -
-   
-   # Or with manual editing
-   git commit -am "$(./git-context | llm "Write a commit message")" -e
+   git commit -am "$(./git-context | llm -m openrouter/anthropic/claude-3.5-haiku)" -e
    ```
 
-### Scenario: Code Refactoring with Git Integration
-
-When working on larger refactoring tasks:
-
-1. Generate context with git history for better understanding:
-   ```bash
-   ./context --include="src/utils/parser.js" --git > parser_context.txt
-   ```
-
-2. Send the context to an LLM with your request (e.g., "Refactor this parser to improve performance")
-
-3. Apply the suggested changes:
-   ```bash
-   # Save LLM response to response.md or pipe directly
-   cat response.md | ./apply-md --dry-run
-   cat response.md | ./apply-md
-   ```
-
-4. Generate commit context and message in one step:
-   ```bash
-   git commit -am "$(./git-context --prompt=prompts/conventional_commit.txt | llm "Generate a detailed commit message")" -e
-   ```
-
-## Customization
-
-All prompts used in the scripts are stored in the `prompts/` directory as text files, making them easy to customize for your specific needs.
-
-### Custom Prompts
-
-You can create your own prompt templates for different scenarios:
-
-```bash
-# Create a custom prompt for code review
-echo "Please review this code and identify potential bugs and security issues." > prompts/review_prompt.txt
-
-# Use your custom prompt with the context generator
-./context --include="src/*.js" | cat - prompts/review_prompt.txt | llm
-```
-
-### Integration with Other Tools
+## Integration with Other Tools
 
-These scripts are designed to work with various LLM CLI tools and other Unix utilities:
+poorcoder works with various tools to create a seamless workflow:
 
+- **Web LLMs**: Claude.ai, ChatGPT, Grok, etc.
 - **LLM CLI tools**: `llm`, `sgpt`, `chatgpt-cli`, etc.
 - **Clipboard utilities**: `pbcopy`/`pbpaste` (macOS), `xclip` (Linux)
-- **Text processing**: `sed`, `awk`, `grep`, etc.
 - **Version control**: `git`
 
 ## Contributing