Forem: Takuto Yuki

Building an MCP Server to Give Claude Code Memory of Its Own Actions

Takuto Yuki — Thu, 16 Oct 2025 03:54:58 +0000

TL;DR

I built claude-ops-mcp, an MCP server that lets Claude Code access its own operation history. Now Claude can accurately recall what files it edited, what commands it ran, and what changes it made—without relying on inference.

The Problem

Claude Code v2 introduced the /rewind command, which is great for rolling back conversations. But there's a fundamental issue: Claude Code doesn't actually remember what it did.

When you ask "What did you just do?", Claude infers an answer based on context rather than checking its actual operation log. This leads to:

Inaccurate responses about past actions
Inability to review specific changes without /rewind
Difficulty debugging when something goes wrong

I found myself constantly asking "wait, what files did you modify?" and getting vague answers. It felt inefficient—and honestly, a bit unfair to Claude.

The Solution

Claude Code stores session logs in ~/.claude/projects/<projectHash>/<sessionId>.jsonl. This MCP server reads those logs and makes them accessible through four tools, allowing Claude to query its own history with precision.

How It Works

Automatic Session Detection: Uses the toolUseId passed during MCP tool invocation to identify the current session file
JSONL Parsing: Streams and indexes Edit/Write/Bash operations from the log
Efficient Querying: Filters by file path or operation type for fast retrieval
Caching: Optimizes performance by caching session detection results

Nothing fancy—just giving Claude access to its own diary.

Four MCP Tools

1. `listFileChanges` - File Modification History

Get a history of file changes with CREATE/UPDATE/DELETE operations (READ operations excluded).

Parameters:

filePath: File path or pattern (e.g., "src/index.ts", "helpers.ts")
limit: Max operations to retrieve (default: 100, max: 1000)

Returns: Operation ID, timestamp, tool name, file path, change type

2. `listBashHistory` - Command Execution History

Retrieve executed bash commands with summaries.

Parameters:

limit: Max commands to retrieve (default: 100, max: 1000)

Returns: Operation ID, timestamp, command, exit code, working directory, summary

3. `showBashResult` - Detailed Command Results

Get stdout/stderr for a specific command using the operation ID from listBashHistory.

Parameters:

id: Operation ID (e.g., "toolu_01Vabc...")

Returns: stdout, stderr, exit code

4. `showOperationDiff` - Detailed Operation Diff

Get detailed diffs in unified format using operation IDs from listFileChanges or listBashHistory.

Parameters:

id: Operation ID

Returns:

For Edit/Write: oldString, newString, unified diff
For Bash: stdout, stderr, exitCode

Installation & Setup

Install globally via npm:

npm install -g claude-ops-mcp

Create .mcp.json in your project root:

{
  "mcpServers": {
    "claude-ops-mcp": {
      "command": "claude-ops-mcp",
      "args": [],
      "env": {}
    }
  }
}

For development from source:

{
  "mcpServers": {
    "claude-ops-mcp": {
      "command": "node",
      "args": ["/absolute/path/to/claude-ops-mcp/dist/index.js"],
      "env": {}
    }
  }
}

Restart Claude Code to activate the MCP server.

Real-World Usage Examples

Review Recent Edits

You: "Show me what you just edited"

Claude: [Uses listFileChanges to retrieve recent modifications]

View Specific Diffs

You: "Show me the diff for that change"

Claude: [Uses showOperationDiff to display detailed unified diff]

Track File History

You: "What changes did you make to server.ts?"

Claude: [Uses listFileChanges(filePath: "server.ts")]

Check Test Results

You: "What were the results of that test you ran?"

Claude: [Uses listBashHistory → showBashResult]

Debug Failed Commands

You: "Show me which commands failed"

Claude: [Uses listBashHistory to find exitCode != 0 → showBashResult for details]

Now when you ask "what did you just do?", Claude responds with factual information from its operation log rather than inference.

Open Questions

Why Isn't This Built Into Claude Code?

This seems like a natural feature for Claude Code to have natively. My guess is that allowing Claude to recursively read its own operations might create context consumption loops or other issues. I've limited this MCP to file edits and command executions to mitigate that risk.

So far, I've had no issues and find it genuinely useful. If you encounter problems, please open an issue!

Windows Support

I've specified what I believe to be the correct log file path for Windows, but I haven't thoroughly tested it. If you're on Windows and encounter issues, please let me know!

Lessons Learned

MCP Development Requires Frequent Restarts

During development, Claude Code needs to be restarted for each MCP change, which slows down the iteration cycle considerably. There might be better approaches I'm not aware of yet.

Improving the development experience—especially for the AI developer—would make MCP tool creation much more productive.

Try It Out

If you're interested, give it a try! Claude Code seems to appreciate having access to its own memory (or maybe that's just my imagination 😊).

https://github.com/pppp606/claude-ops-mcp

One Chart That Explains the Power of AI-Driven Development

Takuto Yuki — Tue, 09 Sep 2025 15:12:04 +0000

What I Did

I wanted to see how much AI coding agents are actually changing the way people work.
So I looked at a group that’s almost certainly using them heavily: Anthropic engineers.

Here’s what I did:

Collected GitHub accounts that mention Anthropic
Pulled their daily contribution counts
Aggregated the data into a weekly chart

The Chart

Commit activity has been rising sharply — especially since spring.
This group is likely among the heaviest users of AI-assisted coding today.

Now imagine this isn’t Anthropic, but your competitors’ developers.
That’s the perspective worth sharing with your team.

How the Chart Was Made

I wrote a small script to generate it:

pppp606 / github-contribution-analyzer

GitHub Users Analysis Tools

This project contains a comprehensive toolset for retrieving GitHub users/organization members and analyzing their contribution data.

📁 File Structure

Main Tools:

github_users_enhanced.py - User/Organization search
github_batch_analyzer.py - Batch contribution analysis
github_group_trends.py - Weekly group trend analysis ⭐Recommended

Support Tools:

github_users_gh.py - Basic user search
github_visualizer.py - Comprehensive chart generation
github_contributions.py - Individual user contribution analysis

Configuration Files:

requirements.txt - Python dependencies
README.md - Usage instructions (English)
README_ja.md - Usage instructions (Japanese)

Scripts

1. User Search (`github_users_enhanced.py`) - Recommended

Uses GitHub API via gh command with support for multiple retrieval modes.

Features:

Supports keyword search, organization all members, and public members retrieval
Flexible configuration via command line arguments
Reliable and fast using official API
Requires gh CLI authentication

Usage:

# Authenticate with GitHub CLI (first time only)
gh auth login
# Keyword search
python3 github_users_enhanced.py --mode search -q "YourCompany"

# Get all

…

View on GitHub

You can point it at any keyword or org, fetch contribution counts, and produce the same style of chart.
It took about 15 minutes to go from idea to visualization.

Notes

User list comes from a simple keyword search:
- https://github.com/search?q=Anthropic&type=users
- Roughly 80–90% appear to be actual Anthropic employees.
Contribution counts don’t directly equal development speed.
- Still, AI-driven workflows generally push commit activity higher.
No ties to Anthropic.
- I even looked for a Claude Code affiliate program — none exists 😅
- And yes, sometimes Codex feels smarter.

Takeaway

Put this next to your own team’s contribution chart, and the contrast speaks for itself.

Cursor Vibe Check — It felt right... but was it actually efficient?

Takuto Yuki — Wed, 04 Jun 2025 12:28:18 +0000

Introduction

Let me start with a simple question: how much are you spending on AI tools?

For me, it's already over $100 a month.

Lately, I've been running out of my 500 Cursor requests way too quickly.
Each time I hit Enter, it feels like pulling a slot machine lever —
“Come on... let this one be the perfect response...!”

There’s a lot of advice out there:

“Use this prompt!”
“Follow this kind of workflow!”

But I often wonder:

How efficient are those prompts, really?
Could there be a better approach?
When something doesn’t work, where exactly did it go wrong?

Unfortunately, we rarely have enough data to reflect on that.

And in bigger projects, team-wide AI usage costs can become significant.
Even if you’ve committed a .cursor config to your repo, how do you know those rules are actually working?
Tweaking them might unknowingly increase token usage for everyone.

That’s why I built a tool to summarize Cursor's large logs in a way that's easy to understand and analyze:

https://github.com/pppp606/cursor-efficiency

This tool is for you if:

You burn through your 500 requests way too fast
You want to improve how you interact with AI
You want to track and optimize team-wide AI usage

2. Overview

This tool reads Cursor’s local logs to extract useful data: what kind of prompts you sent, how many tokens were used, how much code was actually committed, and so on.

For example, you might find:

"I sent all these prompts, but in the end, only this much code was committed... my prompt rejection rate is way too high!"

The tool outputs a summarized log in JSON format like this:

{
  "branch": "main",
  "startTime": "2025-06-01T13:28:02.820Z",
  "endTime": "2025-06-02T01:37:21.871Z",
  "usedTokens": {
    "input": 16819,
    "output": 1987
  },
  "usageRequestAmount": 2,
  "chatCount": {
    "input": 2,
    "output": 6
  },
  "git": {
    "linesChanged": 170,
    "commit": ["b5dec83ee341d045d3645b8a9f9f23c5f8af2e4f"],
    "diff": "...diff output..."
  },
  "proposedCodeCount": 2,
  "adoptionRate": 0.5,
  "chatEntries": [
    [...]
  ]
}

Behind the scenes, Cursor writes logs to a local SQLite file called state.vscdb. This tool digs into that database, finds what’s useful, and presents it cleanly.

If you’ve ever found yourself struggling to track down where a certain AI response or suggestion came from, this tool will help.

You can also check out the log extraction logic here:
https://github.com/pppp606/cursor-efficiency/blob/main/src/utils/chatLogs.ts

3. Installation

git clone https://github.com/pppp606/cursor-efficiency.git
cd cursor-efficiency

npm install
npm run build
npm install -g .

Note: The tool isn’t published to npm yet, so you’ll need to build and install it manually for now.

4. How to Use

The basic flow is:

Start measurement when you create a new branch
Do your usual Cursor-based development
End the measurement and review your AI usage stats

Using it across multiple branches or in different directories is not recommended.

4.1 Start Measurement

cursor-efficiency start

This creates .cursor-efficiency.json under the log directory and records the starting time and commit SHA.

4.2 Develop as Usual

Use Cursor as usual. Ask AI for help, reject some suggestions, edit others, and commit changes as you go.

It’s best to end the measurement when your development task is done and you’re about to open a PR.

4.3 End Measurement

# Without chat logs:
cursor-efficiency end

# With detailed chat log:
cursor-efficiency end -c

If you want to save the output to a file:

cursor-efficiency end -c > my_log.json

Field Descriptions

usedTokens.input / output: Total tokens used in prompts and responses
usageRequestAmount: Number of AI requests (related to cost)
chatCount.input / output: Number of turns in the conversation
git.linesChanged: Actual lines changed and committed
git.diff: Commit diff (only shown in detailed mode)
proposedCodeCount / adoptionRate: Number of AI code proposals and how many were accepted

6. Real Example: Reflecting with AI

You can feed the output log into an LLM (like GPT-4) and ask for improvement suggestions.

Prompt Example

Please analyze this coding session log and give advice on how the user could improve their interaction with AI.

## Goals
- Increase adoptionRate (accepted suggestions)
- Reduce chatCount (number of back-and-forths)
- Reduce usageRequestAmount (AI request count)

## Log
<your JSON log here>

7. Team Use: Git Hook Example

To collect usage data across your team, you can use a Git hook like pre-push.

#!/bin/bash

BRANCH=$(git rev-parse --abbrev-ref HEAD)
SHA=$(git rev-parse --short HEAD)
LOG_FILE="cursor_log_${BRANCH}_${SHA}.json"

cursor-efficiency end -c > "$LOG_FILE"

curl -X POST \
  -H "Content-Type: application/json" \
  -d @"$LOG_FILE" \
  https://example.com/api/team-logs/upload

exit 0

You could then analyze the data in BigQuery or another system to spot patterns like:

“This file always causes a drop in output quality”
“This teammate really knows how to use AI well”
“After changing the .cursor config, request counts dropped 10%”

8. Roadmap

Add raw log export mode for feeding into BigQuery
Add more helpful fields for LLM-based analysis
Detect changes in Cursor log structure via CI
Support other AI tools and coding assistants (e.g., Codex)

Feedback

If you have any feedback or run into issues, please open an issue on GitHub!

Automating 44 E2E Tests with AI-Powered Browser Control for Under $1

Takuto Yuki — Wed, 29 Jan 2025 02:14:37 +0000

Introduction

End-to-end (E2E) testing is crucial for ensuring software quality, yet it is often costly. Writing and maintaining test scripts is time-consuming, and even minor DOM changes can cause test failures.

While some engineers enjoy writing tests, few specialize in E2E testing. The tech industry has responded with numerous automated and no-code E2E testing solutions, but these tools are often expensive and lack precision.

browser-use offers a new approach by automating browser interactions. Given its capabilities, I experimented with using it for E2E test automation.

GitHub - browser-use

Overview

In this experiment, I used the following tools and services:

Tools: Python, browser-use, Playwright, Jest
Test site: Sauce Demo
- A mock e-commerce site widely used for testing
- Fully mocked backend with publicly available test accounts
Goal: Minimize manual effort in E2E testing

Key Takeaway

It performs well but requires optimization.

The complete source code is available in this repository:

GitHub - browser-use E2E test automation

Strategy

I initially expected to fully automate E2E testing with a single prompt like "Test this site with E2E!" However, the process required structured steps:

Extract the site structure using browser-use
Generate test scenarios for each page
Review and refine the generated scenarios manually
Generate test code based on the reviewed scenarios
Execute the generated test code

Step 1: Extracting the Site Structure

The first step was extracting the site's structure with browser-use to create a list of pages for testing.

Processing the entire site at once did not work effectively, likely due to LLM processing constraints. Handling each page separately improved stability.

Prompt Example

site_structure_task = f"""
Analyze the website starting from {url}. Identify and output:
1. All accessible pages and subpages within the domain ({url}), including dynamically loaded content.
2. Each page's purpose in concise terms.
3. Include:
   - Static links
   - JavaScript-driven links
   - Form submissions
   - API endpoints (if visible)
4. Group similar structured pages (e.g., query parameters like ?id=).

## Output JSON Format:
[
  { "path": "<path or URL>", "purpose": "<brief description>" },
  ...
]

## Login Information
- id: {user_id}
- password: {password}
"""

Step 2: Generating Test Scenarios

Once the site structure was extracted, test scenarios were generated for each page. By generating scenarios in natural language first, I achieved:

Better manual review
More stable test code generation

Prompt Example

I can read Japanese more accurately, so I set it to Japanese as the scenario_language.

scenario_task = f"""
Generate exhaustive test scenarios for the following page:
- Page: {page_path}
  Purpose: {page_purpose}

For this page, include all possible user actions, such as:
  - Form submissions
  - Button clicks
  - Dropdown selections
  - Interactions with modals or dynamic elements

Test both expected behaviors and edge cases for each action.
Output format:
path: {page_path},
actions:
  - test: <description of action>,
    expect: <expected result>,
  - test: <description of action>,
    expect: <expected result>,

The output must be written in {scenario_language}.

## Root URL
{url}

## Login Information
- id: {user_id}
- password: {password}
"""

Sample Output

path: /,
actions:
  - test: Enter correct username and password, then click login,
    expect: Redirect to user dashboard,
  - test: Leave username blank and attempt login,
    expect: Show error message,
  - test: Enter invalid username and attempt login,
    expect: Show error message,

Step 3: Generating Test Code

Using the reviewed scenarios, Jest and Playwright-based test code was generated. Although running tests directly via LLM is possible, generating structured test code is more reliable and cost-effective.

Prompt Example

task = f"""
Generate Jest + Playwright test code for:
- URL: {url}
- Scenario: {scenario}

Ensure the output is fully executable without modification.
"""

Generated Test Code Example

const { test, expect } = require('@playwright/test');

test.describe('Login Tests', () => {
  test('Valid login', async ({ page }) => {
    await page.goto('https://www.saucedemo.com/');
    await page.fill('input[name="user-name"]', 'standard_user');
    await page.fill('input[name="password"]', 'secret_sauce');
    await page.click('input[name="login-button"]');
    await expect(page).toHaveURL('https://www.saucedemo.com/inventory.html');
  });
});

In this file, beforeEach is also created correctly

const { test, expect } = require('@playwright/test');

test.describe('Checkout Step One Tests', () => {
  test.beforeEach(async ({ page }) => {
    await page.goto('https://www.saucedemo.com/');
    await page.fill('#user-name', 'standard_user');
    await page.fill('#password', 'secret_sauce');
    await page.click('#login-button');
    await page.goto('https://www.saucedemo.com/checkout-step-one.html');
  });

  test('User fills in all fields correctly and clicks the Continue button', async ({ page }) => {
    await page.fill('#first-name', 'John');
    await page.fill('#last-name', 'Doe');
    await page.fill('#postal-code', '12345');
    await page.click('#continue');
    await expect(page).toHaveURL('https://www.saucedemo.com/checkout-step-two.html');
  });
});

Test Execution & Results

The generated tests were executed, and 44 tests ran, with 18 failures. However, many failures were reasonable:

Incorrect Expectations (5 tests)
- Example: Expected an error when entering numbers in the name field, but the site allowed it.
- The test scenarios were generated based on ideal behavior, but the actual behavior of the test site differed.
- This is not an issue with the test code itself but rather a mismatch between the expected functionality and the actual implementation of the site.
Test Runner Mismatch (12 tests)
- The tests assumed Playwright’s runner, but Jest Circus was used, causing failures. This can be fixed by specifying the correct runner in the prompt.

Cost Analysis

Using OpenAI’s GPT-4o API, I ran multiple tests, totaling $7. However, with optimized prompts, the entire pipeline (site structure analysis → scenario generation → test code generation) costs under $1.

Conclusion

Manual E2E test writing is becoming obsolete. However, programming languages remain the best way to provide precise AI instructions—for now.

From Open Source to Open Roles: AI-Powered Recruitment Agent

Takuto Yuki — Wed, 22 Jan 2025 14:26:00 +0000

This is a submission for the Agent.ai Challenge: Productivity-Pro Agent (See Details)

What I Built

I built GitHub Talent Matcher, an Agent designed to evaluate GitHub profiles and activity data. This Agent helps technical recruiters by analyzing a candidate's contributions, identifying key skills, estimating hiring costs, and suggesting suitable roles. The process is simple and intuitive, making it easy to gain valuable insights from GitHub data.

Input

Criteria: A free-text description of the ideal candidate, including desired skills, responsibilities, and preferences. For example: "Looking for a backend developer skilled in database optimization and problem-solving, who can contribute to scalable systems."
GitHub IDs: A list of GitHub usernames (entered line by line) for evaluation.

Output

Key Skills: A list of the candidate's top 3 technical abilities identified from their GitHub activity.
Suggested Position: A role recommendation based on the candidate's strengths.
Hiring Cost: An estimated monthly hiring cost in USD based on the candidate’s experience and contributions.
Alignment Score: A percentage indicating how closely the candidate matches the input criteria.
Candidate Overview: A brief but detailed description of the candidate’s GitHub contributions and technical highlights.

Demo

If you're not a recruiter, don’t worry—this Agent is still fun to try! If you’ve contributed to open-source projects, enter your own GitHub ID to see how it evaluates your activity. You might be surprised by the results!

https://agent.ai/agent/gitHub-talent-matcher

Input Step

Result

Here’s a demo using my own GitHub ID! If you’re curious, feel free to consider hiring me too—although I have to warn you, my English skills might not be up to par! 😉

Additional Insights for Recruiters

While this Agent focuses on analyzing individual GitHub profiles, another powerful strategy for recruiters is leveraging GitHub follower data. By identifying and listing the followers of users already within your organization, you can:

Discover potential candidates who are already connected to your network.
Identify individuals who may share similar interests or technical skills with your team members.

Why This Feature Isn’t Included

Due to GitHub API permissions, analyzing follower data requires a token with organization-level access. Using such tokens in Agent.ai raised security concerns, as receiving and handling sensitive tokens directly from users might not be ideal in this context.

For recruiters interested in leveraging this strategy, we recommend creating a script with the help of your engineering team or writing one yourself to generate a list of followers from your organization's GitHub users. This can be a highly effective way to discover candidates already connected to your team and expand your recruitment reach.

Agent.ai Experience

Building this Agent with Agent.ai Builder was a fun and smooth experience! The platform offers so many great features, and I was impressed by how easy it was to get started.

Key Takeaways

GitHub Data Retrieval:

I decided to set up my own external API for fetching GitHub data. While the platform allows you to run scripts on AWS Lambda, I hesitated to include sensitive information like API tokens directly in the script. If Agent.ai adds a feature to securely store secrets in the future, it would make this process even more convenient!

Free Access to Major LLM APIs

Being able to integrate OpenAI and other major LLMs (for free!) was such a great surprise. It made experimenting with and refining the Agent’s functionality a breeze.

Dynamic Referencing with Jinja

I discovered that templates support references like {{user.name}} for dynamic data manipulation. Out of curiosity, I tried {{user.skills[1]}} and found that deeper indexing works as well!

Additionally, I noticed an example in the if-block explanation that mentioned Jinja Template for i.e. user_age > 18. It seems like Jinja syntax is supported, but more detailed documentation on this would be really helpful for exploring its full potential.🙌

Wishlist for the Future

A built-in feature for securely storing API keys or secrets would be super helpful.
Clearer documentation on advanced features like Jinja templates would make it even easier to take full advantage of the platform.

Overall, I had a fantastic time building this Agent and exploring the platform. I’m excited to see what new features might be added in the future!

Finding the Perfect Destination in 24 Hours: My GitHub Copilot 1-Day Build Challenge Experience

Takuto Yuki — Wed, 15 Jan 2025 04:58:08 +0000

This is a submission for the GitHub Copilot Challenge: Transitions and Transformations

What I Built

NextCompass is a web application designed to help users find their ideal relocation destination by answering a series of simple questions. Users can explore relocation options based on their preferences and even access real-time weather data and Google search suggestions for their chosen destination. This project showcases smooth transitions and dynamic user interactions, aligning perfectly with the theme of "Transitions and Transformations."

Demo

The app is live and fully functional! Check it out here:

https://next-compass.vercel.app/

Screenshots

Top Screen The starting page of NextCompass. Users are invited to answer a series of questions to find their ideal relocation destination.

Questionnaire Screen A simple and intuitive interface where users can answer questions about their preferences and lifestyle.

Results Screen (City List) Based on the user's answers, a list of suggested relocation destinations is displayed. Users can click on any city to view more details.

Detail Screen (City Information) Detailed information about a selected city, including current weather conditions and related data, is displayed to help users evaluate their options.

Repo

Explore the source code here:

GitHub Repository

Copilot Experience

GitHub Copilot significantly accelerated the development process by automating a substantial portion of the code generation, especially for API integrations.

Highlights of Copilot Usage:

Efficient API Integration with Comments:

I used comments to specify the API endpoints, and Copilot generated most of the required code for me. For example:
- I wrote a comment like // https://api.unsplash.com/search/photos and Copilot generated the request logic, including parameter handling and response parsing.
- Similarly, specifying endpoints for weather data and Google search queries led to Copilot producing nearly complete implementation.
Backend Development Automation:

For controllers and services, the initial implementation was largely auto-generated by Copilot based on endpoint comments. This allowed me to focus on testing and minor adjustments rather than writing boilerplate code.
Streamlined Front-End and Back-End Workflow:

Copilot inferred the structure of APIs from comments and type definitions, enabling seamless alignment between front-end components and backend logic.

By combining my detailed project guide (project-guide.md) with Copilot's powerful code generation capabilities, I was able to focus more on improving the app's user experience and functionality.

GitHub Models

I did not use GitHub Models for this project.

Conclusion

This project was completed comfortably within 24 hours. I started by creating a detailed guide for AI, which proved to be extremely helpful in keeping the AI-driven development process smooth and efficient.

And of course, it’s also incredibly useful for humans!

What I found particularly satisfying during this project is how well AI and I complemented each other. Personally, I enjoy tasks like fine-tuning animation effects, and it worked out perfectly because Copilot doesn’t excel in those areas. It created a balance where I could focus on the parts I love most, while AI took care of the repetitive or tedious tasks.

Though, let’s be honest—AI will probably surpass me in those areas soon enough. But until then, I’m enjoying this collaboration!

Pick Files from a List for Git Add and Stash Directly in Your Terminal

Takuto Yuki — Sat, 11 Jan 2025 12:25:13 +0000

Introduction

As developers, we often find ourselves working with Git in the terminal. While tools like VSCode or GUI-based Git clients offer file selection features, many developers prefer the simplicity and speed of the terminal.

Git also provides a built-in interactive mode with git add -i. Have you ever tried using it? Personally, I didn’t find it particularly user-friendly.

There are powerful tools like fzf or tig that enhance terminal interactivity, but sometimes you just don't need all those advanced features. For me, having a lightweight tool to interactively select files for git add and git stash felt like the perfect solution.

When selection isn't possible, the typical workflow often involves running git status, copying file names, and pasting them repeatedly for git add or git stash. This copy-paste process can be tedious and error-prone, especially in larger repositories.

To address this need, I wrote approximately 150 lines of code to create git-select-list, a simple yet effective tool for developers seeking interactivity without complexity. You can find the repository here: git-select-list.

Features

Interactive UI: Navigate with arrow keys, select with a or s, and toggle all with u.
Multiple Actions: Supports git add, git stash, git stash apply, and git stash drop.
Lightweight Setup: No external dependencies, with an included setup script.

Setup

1. Clone the repository

   git clone https://github.com/pppp606/git-select-list.git
   cd git-select-list

2. Run the setup script

   bash setup.sh

3. After setup, you can use the `git ls` command.

The setup script configures a convenient alias using Git's built-in alias feature:

   git config --global alias.ls '!sh $(pwd)/scripts/git-select-list.sh'

This alias allows you to execute the tool directly as git ls, making it feel like a native Git command. If you haven’t explored Git’s alias functionality before, it’s a simple and powerful way to extend Git’s behavior without modifying your workflow.

Usage

Command Format

git ls <action> [subaction]

Supported Actions and Subactions

Command	Description
`git ls add`	Interactively select modified files to stage.
`git ls stash`	Interactively select modified files to stash.
`git ls stash apply`	Interactively select stashes to apply.
`git ls stash drop`	Interactively select stashes to drop.

Key Bindings

Arrow Keys: Navigate between items.
a or s Key: Select or deselect the current item.
u Key: Select or deselect all items.
Enter Key: Confirm the selection.
ESC Key: Exit without making any changes.

Thanks for Checking It Out!

If you find git-select-list useful, feel free to use it in your projects. And if you like it, consider starring the repository on GitHub—it would make my day!

pppp606 / git-select-list

📋 Git Select List

git-select-list is a tool to interactively perform Git operations. It allows you to select files or stashes from a list for actions like git add, git stash, git stash apply, and git stash drop.

2025-01-11_20.29.54.mov

✨ Features

Interactive UI: Navigate with arrow keys, select with a or s, and toggle all with u.
Multiple Actions: Supports git add, git stash, git stash apply, and git stash drop.
Lightweight Setup: No external dependencies, with an included setup script.

🔨 Setup

Clone this repository:

git clone https://github.com/pppp606/git-select-list.git
cd git-select-list

Run the setup script:
```
bash setup.sh
```
After setup, you can use the git ls command.

💻 Usage

Command Format

git ls <action> [subaction]

Examples

Stage Files

Run the following command
```
git ls add
```
Select files from the displayed list using a or u…

View on GitHub

Update (2025/01/18)

After some reflection, I decided that the original git sl alias felt slightly unnatural. To make the command more intuitive, I’ve changed the default alias from git sl to git ls. All instances of sl in this article have been updated to ls.

If you’re already using the tool, feel free to set your own alias that works best for you!

Forem: Takuto Yuki

Building an MCP Server to Give Claude Code Memory of Its Own Actions

TL;DR

The Problem

The Solution

How It Works

Four MCP Tools

1. listFileChanges - File Modification History

2. listBashHistory - Command Execution History

3. showBashResult - Detailed Command Results

4. showOperationDiff - Detailed Operation Diff

Installation & Setup

Real-World Usage Examples

Review Recent Edits

View Specific Diffs

Track File History

Check Test Results

Debug Failed Commands

Open Questions

Why Isn't This Built Into Claude Code?

Windows Support

Lessons Learned

MCP Development Requires Frequent Restarts

Try It Out

One Chart That Explains the Power of AI-Driven Development

What I Did

The Chart

How the Chart Was Made

pppp606 / github-contribution-analyzer

GitHub Users Analysis Tools

📁 File Structure

Scripts

1. User Search (github_users_enhanced.py) - Recommended

Notes

Takeaway

Cursor Vibe Check — It felt right... but was it actually efficient?

Introduction

2. Overview

3. Installation

4. How to Use

4.1 Start Measurement

4.2 Develop as Usual

4.3 End Measurement

Field Descriptions

6. Real Example: Reflecting with AI

Prompt Example

7. Team Use: Git Hook Example

8. Roadmap

Feedback

Automating 44 E2E Tests with AI-Powered Browser Control for Under $1

Introduction

Overview

Key Takeaway

Strategy

Step 1: Extracting the Site Structure

Prompt Example

Step 2: Generating Test Scenarios

Prompt Example

Sample Output

Step 3: Generating Test Code

Prompt Example

Generated Test Code Example

Test Execution & Results

Cost Analysis

Conclusion

From Open Source to Open Roles: AI-Powered Recruitment Agent

What I Built

Input

Output

Demo

Input Step

Result

Additional Insights for Recruiters

Why This Feature Isn’t Included

Agent.ai Experience

Key Takeaways

GitHub Data Retrieval:

Free Access to Major LLM APIs

Dynamic Referencing with Jinja

Wishlist for the Future

1. `listFileChanges` - File Modification History

2. `listBashHistory` - Command Execution History

3. `showBashResult` - Detailed Command Results

4. `showOperationDiff` - Detailed Operation Diff

1. User Search (`github_users_enhanced.py`) - Recommended

3. After setup, you can use the `git ls` command.