DEV Community: Sabahattin Kalkan

Every Coding Agent Session Starts by Rediscovering Your Repository

Sabahattin Kalkan — Tue, 11 Aug 2026 05:29:15 +0000

I've been using coding agents heavily across real projects.
Claude Code. Codex. Cursor.
They are getting remarkably good at making changes.
But I kept noticing the same thing at the beginning of new sessions.
The agent starts exploring.
It reads package.json.
It looks for entry points.
It walks through directories.
It checks configuration.
It tries to understand conventions.
It finds the important files.
Then the session ends.
A new session starts later, and a surprising amount of that work happens again.
That bothered me.
Not because repository exploration is useless — an agent should inspect the source before making important changes.
The problem is that there is a difference between:
verifying the current source

and:
rediscovering the basic shape of the repository from zero.

I wanted to see whether that second part could become persistent.
So I built Recall.
What Recall is
Recall is a local CLI that derives structured context from a repository and stores it inside the repository itself.
It isn't another coding agent.
It doesn't call an LLM to understand your codebase.
It doesn't require an AI API key.
It doesn't require a cloud account.
The basic idea is:
repository
↓
deterministic scan
↓
.recall/
↓
persistent repository context
↓
Claude Code / Codex / Cursor / any Markdown-capable agent
The generated context can describe things Recall can derive from the repository, including:
architecture
entry points
project conventions
relevant files
risks
workspace structure
repository state
The important word there is derive.
I deliberately didn't want Recall inventing architectural explanations using another model.
If Recall says something about the repository, I want that information to be traceable back to repository evidence.
Why not just use CLAUDE.md or AGENTS.md?
I use these files too.
They solve a different problem.
A file like CLAUDE.md or AGENTS.md is excellent for things such as:
Use pnpm.

Run this command before committing.

Never modify generated migrations manually.

Our API errors follow this convention.
Those are instructions and human knowledge.
But there is another category of context:
Where are the entry points?

How is this monorepo structured?

Which workspace owns this functionality?

Which files appear relevant to this task?

Has the repository changed since this context was generated?
Much of that can be derived from the repository.
I don't want to manually maintain it if a tool can reconstruct it deterministically.
So my mental model became:
AGENTS.md / CLAUDE.md
↓
human intent + instructions

Recall
↓
repository-derived context

Source code + tests
↓
ultimate source of truth
Recall isn't supposed to replace the source.
It's supposed to provide a better map to the source.
The first command
Recall is published as an npm CLI.
Node.js 22+ is currently required.
npx recall-context@latest init
That initializes Recall for the repository.
You can inspect its state with:
npx recall-context@latest status
And generate task-focused context:
npx recall-context@latest context \
--task "Understand the CLI release and packaging workflow" \
--max-tokens 1200 \
--stdout
The result is Markdown, so there is no vendor-specific protocol required.
You can give it to Claude Code.
Or Codex.
Or Cursor.
Or another tool capable of consuming Markdown.
That portability was intentional.
Task-focused context
Generating a giant repository dump isn't particularly interesting.
The harder question is:
What parts of this repository are likely to matter for the task I'm about to perform?

Recall uses deterministic signals to rank relevant files.
Today that includes things such as file paths, names, symbols, workspace relationships and a bounded import graph.
There are no embeddings involved.
There is no semantic model secretly deciding what your application means.
That has an obvious trade-off.
The ranking isn't magically intelligent.
But it is predictable, local and inspectable.
For this version of the project, I prefer that property.
Context has an expiration problem
Persistent context introduces another problem:
stale context can be worse than no context.
Suppose an agent receives a beautiful architectural summary generated three weeks ago.
The repository has changed since then.
The summary still looks authoritative.
Now the context is actively misleading the agent.
Recall therefore keeps a snapshot and exposes repository/context state through commands such as:
npx recall-context@latest status
The goal isn't to pretend generated context is permanently true.
The goal is to know when it should no longer be trusted without checking the repository again.
This area still has limitations. The current implementation is not a perfect semantic change detector, and I don't want to present it as one.
Which leads to something I've been trying to do differently with this project.
What Recall does not prove
I could put several attractive claims on the README:
Saves tokens.

Makes coding agents faster.

Improves accuracy.

Reduces tool calls.

I haven't proven any of them.
So I'm not claiming them.
Recall currently proves something much narrower:
I can deterministically derive reusable repository context, persist it, inspect it, and give it to different coding agents.
Whether doing that materially improves a real agent workflow is an empirical question.
And that's the question I'm interested in now.
There are already other approaches
Repository context and agent memory are becoming an active area.
Some approaches use persistent memory.
Some use embeddings and semantic search.
Some maintain module knowledge.
Others intercept file reads and replace raw files with structural summaries.
Those are valid approaches.
Recall is intentionally narrower.
Its current constraints are:
local
deterministic
repository-derived
inspectable
agent-agnostic
no AI provider required
I don't know yet whether those constraints are enough to make it useful.
But they make the experiment interesting to me.
The limitations are real
Recall is early.
Some important limitations today:
The import graph isn't a full semantic program analysis system.
Task ranking is deterministic rather than semantic.
The current ecosystem support is primarily focused on JavaScript/TypeScript and related Node.js frameworks.
Token estimation is approximate rather than based on each model's tokenizer.
There is no native MCP integration.
There is no editor plugin.
There is no cloud memory layer.
And I'm deliberately not building those things yet.
I'm stopping feature development
This is probably the most important decision I've made around Recall.
Normally this is where I would start adding:
MCP.
Editor integrations.
More languages.
Embeddings.
Team synchronization.
A dashboard.
And six weeks later I would have a much larger product without knowing whether the original idea mattered.
I'm not doing that this time.
Version 0.2.0 is released.
The next phase is validation.
I want to measure real coding tasks with and without Recall and look at things like:
time to first correct edit
repository exploration time
tool calls before the first correct edit
context/token usage
correctness
whether someone voluntarily uses Recall again
That last metric may be the most important one.
If somebody tries Recall once and never reaches for it again, it doesn't matter how sophisticated I make the scanner.
Try it on a real repository
If you regularly use coding agents on non-trivial JavaScript or TypeScript repositories, that's the environment I'm most interested in testing.
Start with:
npx recall-context@latest init
Then try:
npx recall-context@latest context \
--task "Describe the task you're about to give your coding agent" \
--stdout
The project is open source:
GitHub:
https://github.com/sabahattink/Recall
I'm particularly interested in failures.
If the generated context points you toward the wrong files, misses something important, becomes stale incorrectly, or simply doesn't improve your workflow, that's more useful to me right now than another feature request.
Because the question isn't:
How much can I add to Recall?

It's:
Is persistent, deterministic repository context useful enough that you want it again in your next coding-agent session?

That's what I'm trying to find out.

How I Automated My Obsidian Vault with Claude — It Now Works the Night Shift

Sabahattin Kalkan — Thu, 28 May 2026 20:21:28 +0000

I was drowning in my own notes

For about two years, I lived inside Obsidian. Daily notes, fleeting thoughts, meeting takeaways, half-formed ideas at 2am, voice memos I'd transcribe by hand. My vault had over 3,000 notes.

And I remembered almost none of it.

Every morning I'd open my laptop and stare at yesterday's daily note, trying to reconstruct where I was. The vault was full — full of captures that were never synthesized, tasks that were never carried forward, ideas that died in a folder called _inbox. I was doing the work of a knowledge worker but getting none of the compounding returns. Notes went in. Nothing came out.

What made it worse: I knew I was supposed to do the synthesis. Review your notes. Write a morning brief. Connect the dots. But after a full day of work, the last thing I wanted to do was sit down and play editor. So I didn't. And the vault stayed a graveyard.

The real problem isn't note-taking

Here's what I eventually figured out: I wasn't failing at note-taking. I was failing at synthesis — and I was expecting myself to do it at the worst possible time.

Synthesis requires cognitive distance. You need to look at what you captured with fresh eyes. The problem is that "fresh eyes" happen in the morning, and the synthesis work needs to happen after the day is over. That's a structural mismatch, and no productivity system fixes it because it's not a productivity problem.

It's a timing problem. And timing problems are exactly what automation solves.

The thought that changed everything: Claude doesn't get tired at 11pm. It doesn't need cognitive distance — it can read the whole day in one pass and pull out what matters. So I built vault-os to hand that job off.

What vault-os actually does

vault-os has two main jobs: capture anything, anywhere, and synthesize everything while you sleep.

Capture via Telegram bot. I wanted to send notes from my phone without opening Obsidian. The bot uses tag-based routing — anything you send gets sorted into the right section of your daily note automatically. #idea goes into Content Ideas. #signal goes into Research Signals. #link or a bare URL goes into Links to Process. Plain text goes to Captures. Voice messages get transcribed locally and then routed the same way.

Nightly agent at 23:00. A PowerShell script runs 12 phases: it reads your day, runs Claude over your captures, synthesizes patterns, writes an evening review, prepares your morning brief, and carries forward any unfinished tasks. By the time you wake up, your daily note for the new day already has context loaded.

Morning digest API. A REST endpoint serves the morning brief so you can display it anywhere — a home screen widget, a terminal script, a Raycast extension, whatever fits your setup.

Architecture: the two components

server.js — Node.js + Express + Telegraf

The server handles Telegram and the REST API. The core of it is a routing function that decides where each message goes in your daily note:

function routeMessage(text) {
  const t = text.trim();
  if (/^#(idea|fikir)\b/i.test(t))    return '## Content Ideas';
  if (/^#(signal|research|sinyal)\b/i.test(t)) return '## Research Signals';
  if (/^#link\b/i.test(t) || /^https?:\/\//i.test(t)) return '## Links to Process';
  return '## Captures';
}

Simple regex matching. I added Turkish/Azerbaijani aliases (fikir, sinyal) because I switch languages mid-thought constantly. You can extend this to whatever tags your brain uses.

Multi-line messages are handled per-line — if you paste a block of text with five ideas, each line gets routed independently. This matters more than it sounds; it means you can dump a brain dump into Telegram and it lands sorted.

The voice pipeline runs: OGG (Telegram's format) → ffmpeg converts to 16kHz mono WAV → whisper-cli transcribes → text goes through the same routing function. The whole thing is synchronous on my machine and takes about 4 seconds for a 30-second voice memo.

REST endpoints are minimal: GET /morning-brief returns the prepared brief as JSON, POST /capture lets other tools push content directly.

nightly-agent.ps1 — PowerShell, 12 phases

I wrote this in PowerShell because it runs as a Windows Task Scheduler job and I didn't want a dependency on a running Node process. The phases are:

FAZ 1-2: Environment check, date setup, locate today's note
FAZ 3 (Claude Think): Read all captured content, run a synthesis prompt, extract key themes, identify what was actually important vs. noise
FAZ 4-5: Task extraction, carry-forward logic for incomplete items
FAZ 6 (Morning Brief): Write tomorrow's opening section — not a summary of yesterday, but a launch pad for tomorrow. What's the one thing that matters. What task deserves first attention. What idea is worth developing.
FAZ 7-10: Link processing, research signal digestion, content angle extraction
FAZ 11 (Evening Review): Appended to today's note — a short human-readable synthesis of the day that you can read before sleep
FAZ 12: Cleanup, log rotation, error reporting

The Claude API calls follow a consistent pattern: write the prompt to a temp file, call claude --print with --max-turns 1, capture stdout, clean up.

$prompt | Out-File -FilePath $tmpFile -Encoding UTF8
$result = & claude --print --max-turns 1 $tmpFile 2>$null
Remove-Item $tmpFile -ErrorAction SilentlyContinue

I use --max-turns 1 everywhere in the nightly agent because I don't want back-and-forth — I want one focused output per phase. This also keeps costs predictable. A full nightly run on a moderately active day costs me about $0.04.

What a daily note actually looks like

The daily note template has fixed sections that the automation respects:

# 2026-05-29

## Morning Brief
<!-- written by nightly agent from previous night -->

## Captures
<!-- plain Telegram messages land here -->

## Content Ideas
<!-- #idea tags land here -->

## Research Signals
<!-- #signal tags land here -->

## Links to Process
<!-- #link tags and bare URLs land here -->

## Evening Review
<!-- written by nightly agent at 23:00 -->

During the day, you're just sending messages. The structure fills itself in. The Morning Brief is already there when you open Obsidian. The Evening Review appears after the agent runs. You never touch the note directly unless you want to.

This matters for adoption: if the automation requires you to maintain the structure, you'll break it within two weeks. The structure has to be robust enough to survive a messy day where you just dump text into Telegram without thinking.

Voice capture and why local matters

I almost used OpenAI Whisper API for transcription. It's easier to set up and the accuracy is excellent. I switched to whisper.cpp for one reason: the content of voice notes.

When you're thinking out loud into your phone, you're not performing. You're rough-drafting decisions, processing frustrations, working through half-formed ideas that you wouldn't put in a document. That content is genuinely private — not in a paranoid way, but in the way that a sketchbook is private. It's your unedited thinking.

Sending that audio to an API means it transits servers you don't control. Running whisper.cpp locally means the audio never leaves your machine. The model is a file on disk (ggml-small.bin, 466MB), the process runs in a subprocess, and nothing goes over the network.

Accuracy with small is good enough for most voice notes — I get the occasional mishearing on proper nouns and mixed-language sentences, but the meaning survives. If you mostly dictate in a single language, small is the right tradeoff. medium (1.5GB) is noticeably better for multilingual.

What I wake up to

Here's what the Morning Brief section looks like on a real morning:

## Morning Brief

Carry-forward: Finish the vault-os README (started yesterday, left at setup section).

Yesterday's thread: Three captures around API cost optimization clustered
with a research signal on context caching. Worth developing.

Content angle ready: "Local-first AI tools" — #idea from Tuesday still
unaddressed, now has supporting signals from two separate sources.

Today's open question: The routing logic handles single-line captures well
but breaks on multi-paragraph pastes. Worth fixing or acceptable?

The brief is not a summary. It's a launch pad. There's a difference: a summary tells you what happened, a launch pad tells you where to start.

Getting started

Prerequisites: Node.js 18+, PowerShell 7+, Claude CLI authenticated, ffmpeg on PATH, whisper.cpp compiled.

git clone https://github.com/sabahattink/vault-os
cd vault-os
./setup.sh
# Edit .env: VAULT_PATH, TELEGRAM_BOT_TOKEN, ANTHROPIC_API_KEY
node dashboard/server.js

For the nightly agent, register scripts/nightly-agent.ps1 as a Windows Task Scheduler job at 23:00:

pwsh -File scripts/install-scheduler.ps1

What's next

I'm building this in public. Three things on the roadmap I actually need:

Decision intelligence endpoint. Extract decisions from a date range — not summaries, but actual choices made and the reasoning captured around them.

Weekly synthesis agent. Look across seven days of evening reviews and find the thread — what was I actually working on this week vs. what I said I was working on.

Mobile shortcut integration. An iOS Shortcut that records audio and POSTs directly to the capture endpoint, bypassing Telegram entirely for voice-only workflows.

If you use Obsidian and your vault isn't working for you — not because you're bad at it, but because synthesis is genuinely hard to sustain — vault-os might be worth trying.

GitHub: github.com/sabahattink/vault-os

Star it if it looks useful. Issues and PRs welcome.

Tags: obsidian, productivity, ai, opensource

I built a permission-first CLAUDE.md + agent stack for Claude Code (free, MIT)

Sabahattin Kalkan — Thu, 14 May 2026 21:01:45 +0000

I've been using Claude Code daily for months. And I kept hitting the same wall:

The agent would just start doing things. No plan. No approval. Just... acting.

It deleted files I didn't want deleted. It refactored things I didn't ask it to refactor. It made "helpful" assumptions that broke my architecture.

So I built Full Stack HQ — a configuration kit that enforces a permission-first workflow. Here's what I learned.

The core problem with AI coding agents

Most people configure their AI agent once (or never) and just... let it go. The result is an agent that:

Makes assumptions about what you want
Takes irreversible actions without asking
Mixes planning and execution in the same step
Has no consistent code style or architectural awareness

The agent is powerful but unpredictable. That's the worst combination in software development.

The solution: permission-first workflow

Nothing happens without your explicit approval. The agent plans, shows you what it intends to do, and waits.

You:    "Add user authentication with JWT"

Agent:  Here's my plan:
        Phase 1: Create auth module + JWT strategy
        Phase 2: Add guards to protected routes  
        Phase 3: Implement refresh token rotation

        [APPROVAL NEEDED] Should I proceed with Phase 1?

You:    PLAN APPROVED

Agent:  [implements Phase 1 only, then stops and reports]

The only valid approval keywords:

PLAN APPROVED
IMPLEMENTATION APPROVED
PROCEED
DO IT

Anything else — the agent waits. No exceptions.

What's inside Full Stack HQ

Component	Count	Description
`CLAUDE.md`	1	Global rules for Claude Code
`GEMINI.md`	1	Global rules for Google Antigravity IDE
Agents	10	Specialist AI personas
Skills	28	Domain-specific knowledge modules
Workflows	10	Slash command procedures

10 Specialist Agents

Instead of one generic agent trying to do everything, you get domain experts:

Agent	What it handles
`frontend-specialist`	React, Next.js, Tailwind
`backend-specialist`	NestJS, Node.js, APIs
`database-specialist`	Prisma, PostgreSQL, migrations
`architect`	System design, trade-offs, ADRs
`code-reviewer`	Quality, patterns, best practices
`test-engineer`	Vitest, Jest, Playwright
`security-auditor`	Auth, OWASP, input validation
`performance-optimizer`	Bundle, queries, rendering
`devops-engineer`	Docker, CI/CD
`documentation-writer`	READMEs, technical writing

Calling them is simple:

Use the database-specialist to design a user schema with soft deletes.

28 Skills

Deep knowledge modules for the tools you actually use:

Frontend: nextjs-app-router, react-best-practices, ui-ux-pro-max, frontend-design
Backend: nestjs-patterns, prisma-workflow, software-architecture
Testing: test-driven-development, systematic-debugging, webapp-testing
Meta: brainstorming, prompt-engineering, skill-creator

10 Workflows (Slash Commands)

/plan       → phased breakdown with approval checkpoints
/brainstorm → explore architecture options
/debug      → systematic root-cause analysis
/create     → implement an approved plan
/enhance    → improve existing code quality
/test       → generate or fix tests
/orchestrate → coordinate multiple agents

Install in 30 seconds

Mac/Linux:

curl -fsSL https://raw.githubusercontent.com/sabahattink/antigravity-fullstack-hq/main/install.sh | bash

Windows (PowerShell):

irm https://raw.githubusercontent.com/sabahattink/antigravity-fullstack-hq/main/install.ps1 | iex

Options:

./install.sh --only-claude        # Claude Code only
./install.sh --only-antigravity   # Antigravity only
./install.sh --force              # Overwrite existing configs

The script detects which IDEs you have installed and configures them automatically.

What gets installed where

~/.claude/
├── CLAUDE.md          ← global rules (Claude Code)
├── agents/            ← 10 specialist agents
└── skills/            ← 28 skill modules

~/.gemini/
├── GEMINI.md          ← global rules (Antigravity)
└── antigravity/
    ├── agents/
    ├── skills/
    └── workflows/

The CLAUDE.md philosophy

The rules file enforces several things I found critical in practice:

1. Separation of planning and execution

The agent never does both in the same step. First it plans, you approve, then it executes. This alone eliminates 80% of unwanted surprises.

2. Role-based reasoning

Before acting, the agent asks: "Who is the right specialist for this?" A database schema question goes to the database specialist, not the frontend agent pretending to know Prisma.

3. Explicit code style

No semicolons. Single quotes. 2-space indentation. Arrow functions. Named exports. These aren't suggestions — they're enforced rules the agent follows on every file, every time.

4. Security checklist

Before every commit: no hardcoded secrets, all inputs validated, no unbounded queries, rate limiting on public endpoints. The agent checks these automatically.

Why it works

The mental model I was missing: AI agents should behave like senior engineers, not interns with root access.

Senior engineers don't start typing when you describe a problem. They think, propose a plan, get sign-off, then execute — one reversible step at a time.

Full Stack HQ enforces this discipline by default.

Repo

⭐ github.com/sabahattink/antigravity-fullstack-hq

MIT license. Open to PRs — especially new agents and skills.

What does your current CLAUDE.md look like? I'd love to see what rules others have found valuable.

Building MailTest: An Open Source Email Deliverability Debugger

Sabahattin Kalkan — Mon, 13 Apr 2026 03:53:52 +0000

Building MailTest: An Open Source Email Deliverability Debugger

The Problem

[Story about client's 50K emails going to spam]

Why Existing Tools Fall Short

Expensive ($100+/month)
No explanations
SaaS lock-in

What I Built

[Demo GIF/screenshots]

Technical Architecture

Backend

NestJS + Fastify (why not Express)
BullMQ for async jobs
RS256 JWT (why not HS256)

Frontend

Next.js 15 App Router
Radix UI primitives
Real-time updates with SSE

Infrastructure

Docker Compose
PostgreSQL 16
Redis 7
Paddle billing

Interesting Challenges

IMAP Polling: How to catch emails reliably
Scoring Algorithm: Weighted checks (SPF 15%, DKIM 20%, etc.)
PDF Generation: Server-side with Puppeteer

Code Snippets

[Show interesting parts]

What's Next

More integrations
Auto-fix features
API monetization

Try It

https://mailtest.scuton.com

Discussion

What features would you want in a deliverability tool?

I built a CLI that diagnoses your code before you ship

Sabahattin Kalkan — Sat, 28 Mar 2026 10:45:57 +0000

I built a CLI that diagnoses your code before you ship
Every NestJS project I've worked on had the same problems:

POST endpoints without auth guards
Hardcoded API keys in source code
.env not in .gitignore
Zero tests
No Swagger documentation

I was tired of catching these manually in code reviews. So I built codediag.
What it does
bashnpx codediag scan .
One command. It auto-detects your stack and runs 5 analyzers:
codediag — Diagnostic Report

Project: my-nestjs-app
Stack: nestjs + typescript + prisma
Score: B+ (87/100)

API Health ███████████████░░░░░ 78
Security ██████████████████░░ 92
Dependencies ██████████████████░░ 91
Testing ████████████████░░░░ 82
Structure █████████████████░░░ 88
The 5 Analyzers

API Health (NestJS) This is the differentiator. codediag uses ts-morph to do real AST analysis of your NestJS decorators — not regex pattern matching. It discovers every endpoint from @get(), @post(), @Put(), @Delete(), @Patch() decorators and checks:

Auth guards: Does this endpoint have @UseGuards()? Especially important for mutating endpoints.
DTO validation: Is the @body() parameter typed with a DTO class?
Swagger docs: Are @ApiOperation() and @ApiResponse() present?
Return types: Is there an explicit return type annotation?

Security The stuff that ends up on HackerNews for the wrong reasons:

Hardcoded secrets (API keys, Stripe keys, AWS keys, GitHub tokens)
.env in .gitignore
Helmet middleware for HTTP security headers
CORS wildcard (origin: '*') detection
Rate limiting package installed
Password hashing library present

Dependencies Your node_modules is a supply chain. codediag treats it like one:

npm audit vulnerabilities
Lock file existence
Deprecated packages
Engine specification
Essential scripts

Testing

Test file existence and count
Framework detection (Jest, Vitest, Mocha, Ava)
Test-to-source file ratio
E2E test directory
Coverage threshold configuration

Structure

README quality
Linter configuration (ESLint or Biome)
Formatter configuration (Prettier)
TypeScript strict mode
NestJS module organization
.env.example presence

Scoring
Each analyzer scores 0-100. The total is a weighted average:
AnalyzerWeightAPI Health25%Security30%Dependencies20%Testing15%Structure10%
Security gets the highest weight because shipping vulnerable code is the worst bug.
CI/CD
One line in your GitHub Actions:
yaml- run: npx codediag scan . --ci --threshold 80
Exits with code 1 if the score drops below your threshold.
What's next

Next.js analyzer
Express route analyzer
Web dashboard with trend tracking
AI-powered fix suggestions
VS Code extension

Try it
bashnpx codediag scan .
Zero config. MIT licensed. 33KB bundled.

GitHub: https://github.com/scuton-technology/codediag
npm: https://www.npmjs.com/package/codediag

I'd love to hear what checks you'd want added. Drop a comment or open an issue!

Stop switching to GitHub.com for standup — I built a CLI for that

Sabahattin Kalkan — Tue, 17 Mar 2026 09:30:29 +0000

Every morning it's the same routine.

Open GitHub. Filter by author. Scroll through commits. Switch repos. Try
to remember what you did yesterday. Piece together a standup from five
different tabs.

Or worse — you're juggling three different repos, two orgs, and a
contractor's fork, and the GitHub web UI has no idea you want to see all
of it at once.

I built gpulse to fix this.

What it does

gpulse is a CLI toolkit that brings the GitHub insights you actually need
into your terminal. Six focused commands, zero browser required.

npm install -g @sabahattinkalkan/gpulse
export GITHUB_TOKEN=ghp_your_token_here

`gpulse standup`

What did you actually do since yesterday?

gpulse standup           # last 24 hours, all repos
gpulse standup -d 3      # last 3 days
gpulse standup -u alice  # another user's activity

Output:
Standup for @sabahattinkalkan
Since Mar 15, 2026 12:00 AM
Commits
a1b2c3d feat: add user authentication (org/app)
d4e5f6a fix: resolve memory leak in worker (org/api)
Pull Requests

42 Add OAuth2 support (org/app)

Reviews

41 Refactor database layer (org/api)

──────────────────────────────────────────
Summary: 2 commits, 2 PRs, 1 review

This is what I actually read out at standup. Copy, paste, done.

`gpulse health`

Repo health score (A–F). Checks README, LICENSE, CI, stale issues.

gpulse health vercel/next.js
# Score: 90/100 (A)

`gpulse review`

PR dashboard — review requests, assigned PRs, your open PRs.

gpulse review
# Review Requested (2)
#   #87 Add rate limiting middleware (org/api)

`gpulse changelog`

Auto-generate changelog from git tags using Conventional Commits.

gpulse changelog -o CHANGELOG.md

`gpulse digest`

Weekly repo digest — commits, issues, merged PRs, contributors.

gpulse digest -d 7

Why terminal?

Context switching kills flow. gpulse keeps you in the terminal where
you're already working. Also useful in SSH sessions and CI scripts.

Setup

npm install -g @sabahattinkalkan/gpulse
export GITHUB_TOKEN=ghp_...

No config files. No YAML. Just the token and go.

Try it

GitHub: https://github.com/scuton-technology/ghx
npm: npm install -g @sabahattinkalkan/gpulse

MIT licensed. What would you add to a GitHub CLI toolkit? Drop it in the comments.

I built a self-hosted LLM proxy that supports 12 providers (Claude, GPT-4o, Gemini, Ollama...)

Sabahattin Kalkan — Mon, 16 Mar 2026 10:18:50 +0000

Every time a new LLM comes out, someone on your team adds a new SDK,
a new API key in .env, and a new set of error handling logic. Repeat
for OpenAI, Anthropic, Gemini, Groq, Mistral, Ollama...

I got tired of this. So I built llm-gateway.

What it does

llm-gateway is a single Go binary that sits between your app and every
LLM provider. Your code sends one request format (OpenAI-compatible),
and the gateway routes it to the right provider based on the model name.

# One endpoint for all providers
curl http://localhost:8080/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d '{"model": "claude-sonnet-4-20250514", "messages": [{"role": "user", "content": "hello"}]}'

# Switch provider by changing the model name — zero code changes
curl http://localhost:8080/v1/chat/completions \
  -d '{"model": "gpt-4o", "messages": [...]}'

# Local model — no API key needed
curl http://localhost:8080/v1/chat/completions \
  -d '{"model": "llama3.2", "messages": [...]}'

Model routing is automatic:

claude-* → Anthropic
gpt-*, o1, o3 → OpenAI
gemini-* → Google
llama* → Ollama or Groq
mistral-* → Mistral
grok-* → xAI
sonar-* → Perplexity
command-* → Cohere

Install in 30 seconds

docker run -p 8080:8080 -v gateway-data:/data scutontech/llm-gateway

Open http://localhost:8080/admin → set your admin password → add API
keys from the Settings page. No .env files, no YAML editing.

Admin dashboard

The gateway ships with a full admin dashboard:

Real-time stats — requests, tokens, latency, error rate, estimated cost
Provider breakdown — which providers you're actually using
Cost analytics — daily/monthly spend by model, with CSV export
Request log — last 50 requests with model, provider, tokens, cost, latency
Dark mode — because of course

Streaming support

SSE streaming works for all providers. The gateway normalizes
Anthropic's stream format to OpenAI's SSE format transparently.

curl http://localhost:8080/v1/chat/completions \
  -d '{"model": "claude-sonnet-4-20250514", "stream": true, "messages": [...]}'

Supported providers

Provider	Models
Anthropic	claude-opus-4, claude-sonnet-4, claude-haiku-4
OpenAI	gpt-4o, gpt-4o-mini, o1, o3-mini
Google	gemini-2.0-flash, gemini-1.5-pro
Groq	llama-3.3-70b, mixtral-8x7b
Mistral	mistral-large, codestral
Cohere	command-r-plus, command-r
xAI	grok-2, grok-2-mini
Perplexity	sonar-large, sonar-small
Together AI	50+ open source models
Ollama	any local model
LM Studio	any local model
vLLM	any hosted model

Why Go?

~15MB binary. Under 100ms cold start. ~20MB memory at idle.
Drop it on a $5 VPS and forget about it.

Try it

GitHub: https://github.com/scuton-technology/llm-gateway
Docker: docker pull scutontech/llm-gateway

MIT licensed. PRs welcome.

Stop writing bad commit messages — I built a free AI CLI for that

Sabahattin Kalkan — Mon, 16 Mar 2026 07:09:21 +0000

We've all done it.

git commit -m "fix"
git commit -m "wip"
git commit -m "asdfgh"
git commit -m "changes"

You're deep in flow, you just want to save progress, and writing a meaningful commit message feels like a speed bump. So you write something meaningless and move on.

The problem? Three months later, you (or your teammate) is trying to understand why a change was made. The git log is full of "fix" and "update" and tells you nothing.

The solution: let AI read the diff

I built ai-commit — a CLI that reads your staged git diff and generates 3 Conventional Commit suggestions for you to pick from.

npm install -g @scuton/ai-commit

Then just:

git add .
aic

You get something like:
? Pick a commit message:
❯ feat(auth): add JWT refresh token rotation
feat(auth): implement rotating refresh token with replay protection
chore(auth): update token lifecycle and Redis TTL strategy
✎ Write my own
✗ Cancel

Pick one, hit enter, done. The whole thing takes 3 seconds.

Free option: Ollama (no API key needed)

This is the part I'm most excited about. You can run it completely free using Ollama — a local LLM runner.

# Install Ollama and pull a model
ollama pull llama3.2

# Use ai-commit with Ollama
aic -p ollama

No API key. No cost per commit. Everything stays on your machine.

Supports Claude and GPT-4o too

If you prefer cloud models:

# Claude (best quality)
export ANTHROPIC_API_KEY=sk-ant-...
aic

# GPT-4o
export OPENAI_API_KEY=sk-...
aic -p openai

Cost is around $0.001 per commit with cloud models — basically free.

Install as a git hook

If you want it to run automatically on every git commit:

aic hook

Remove it anytime:

aic hook --remove

Other useful flags

aic --dry-run        # Preview suggestions without committing
aic --count 5        # Get 5 suggestions instead of 3
aic --lang tr        # Generate in Turkish (or any language)
aic --emoji          # Add emoji to commit type

Programmatic API

You can also use it in your own tools:

import { generateCommitMessages } from '@scuton/ai-commit';

const suggestions = await generateCommitMessages({
  provider: 'anthropic',
  count: 3,
});
console.log(suggestions[0].message);
// "feat(auth): add JWT refresh token rotation"

Try it

GitHub: https://github.com/scuton-technology/ai-commit
npm: npm install -g @scuton/ai-commit

MIT licensed, open source. PRs welcome — especially for new provider integrations.

Happy committing.