I reverse-engineered popular coding-agent instruction repos and distilled their best ideas into Awesome AGENTS.md, a stack-agnostic ruleset for AI coding agents. 📦

The core rules cover small, focused changes, security boundaries, debugging, and verification before an agent says a task is done. More specialized guidance lives in rules/ and is meant to be read when a task calls for it.

Take it for a spin 👉 https://github.com/khasky/awesome-agents-md

What makes this ruleset different:

• One shared core. I can use the same rules with Claude Code, Codex, Gemini, and Cursor. The README explains how to set up each tool.
• Specialized rules on demand. The framework-agnostic core stays lean. Agents read additional modules only when a task calls for them.
• Less code by default. Before adding a new helper or dependency, the agent checks what already exists in the project and what the standard library can do. The goal is the smallest change that solves the problem.
• Evidence before "done". The agent is told to run a relevant check, read the result, and report what passed. A confident "should work now" isn't verification.
• Simple updates. With a local clone, I can pull the latest changes and start a new session. There are no modes to switch between.
• Refined on real projects. I've revised the rules over many iterations while working on real applications. The public commit history shows how they've changed, and I keep revisiting them as models improve.

Try it, make it your own, and tell me what you'd improve. Issues and PRs are welcome! 😉

Follow me for more on AI and Software Development:
khasky — LinkedIn / GitHub / Patreon / Bluesky / Mastodon / Medium / Devto
khaskydev — X / Threads / Instagram / Pinterest / Tumblr / Facebook / VK

Has anyone swapped the provider under Claude Code or Codex to DeepSeek and kept working the same way?

The two clients get there differently, and in both cases the editor, the commands and the permissions stay untouched. 🔌

DeepSeek also works behind OpenCode, Aider, LiteLLM and local Ollama.

Claude Code reaches it over an Anthropic-compatible endpoint, set in the window you launch from:

$env:ANTHROPIC_BASE_URL="https://api.deepseek.com/anthropic"
$env:ANTHROPIC_AUTH_TOKEN="sk-YOUR_DEEPSEEK_KEY"
$env:ANTHROPIC_MODEL="deepseek-flash[1m]"

claude

Codex goes over the Responses API, and the published script writes the provider section, the model catalog and a backup of what it replaced:

irm https://cdn.deepseek.com/api-docs/codex-deepseek-setup-en.ps1 | iex

The reason to do this is cost: at current API rates, cache-miss input plus output per million tokens, DeepSeek Flash is ~7-17x cheaper than Claude Sonnet 5 and ~7-20x cheaper than GPT-5.6 Terra, depending on peak or off-peak and on input against output.

That makes it a strong default for repository exploration, tests, docs, boilerplate, routine refactors, CI fixes and subagent loops. For ambiguous architecture, hard debugging, security review and risky migrations, I would still escalate to a frontier Claude or GPT model.

This compares API rates against API rates, so a fixed monthly subscription is not directly comparable.

If Codex lists the DeepSeek model and the requests still go to the OpenAI endpoint, the provider section is missing and the app has not been fully restarted. 🔧

Do not casually send API keys, .env files, production credentials or large database dumps to a cloud model. For confidential code, prefer local inference or a provider whose retention policy matches your requirements.

https://api-docs.deepseek.com/

I found One Million Tokens. Its rough scale:

1M tokens
~ 750K words
~ 3,000 pages
~ 83 hours of conversation
~ 75K lines of code

🧠 The more interesting part is the timeline.

It starts with GPT-3 at 2,048 tokens in 2020, then walks through ChatGPT 4K, GPT-4 32K, Claude 100K, Gemini 1M, and the later multi-million-token era.

The visual change is kind of absurd when you see all the pages stacked together.

One caveat: maximum context is not the same as perfect memory/retrieval. A model accepting 1M tokens can still fail to use information buried inside that window.

The line-of-code/page conversions are approximations too. I am curious how people here design around 1M+ context in practice.

Do you actually feed giant source sets directly, or still prefer retrieval + smaller focused contexts for cost/attention reasons?

Worth knowing before anyone installs Tencent's teamai-cli on the strength of its front page: the automatic half runs off a hook, and 3 of the 11 agents it lists have none. The rest of it I like.

Tencent has published teamai-cli, which treats that as distribution rather than discipline. One git repo holds skills/, rules/, hooks/hooks.yaml, mcp/mcp.yaml, agents/, docs/ and a culture.md that gets injected into each agent's CLAUDE.md or AGENTS.md. Install is npm install -g teamai-cli, then teamai init <repo-url> against a repo the team can write to.

The flow is the point: teamai push opens a branch and a merge request, a reviewer merges, and the next session's SessionStart hook runs teamai pull so the change lands in everyone's local tools. teamai roles and teamai tags mean nobody is forced to sync skills they do not use.

I counted what it promises per agent before getting interested, since that is what decides whether it reaches your machine. Skills and docs are filled on all 11 agents in the table, hooks and MCP on 8. The automatic pull is itself a hook, so on OpenClaw, Hermes and DeepSeek Harness my read is that you are pulling by hand.

Worth knowing: the shared env/ resource explicitly is not for secrets, and the recall and dashboard halves are both marked beta. Repo: https://github.com/Tencent/teamai-cli

Has a rule ever landed in your shared setup that you would have blocked if you had seen the diff first?

I think fal's recent H3 Max experiments are more interesting than the "AI slop" framing makes them sound.

H3 Max can reportedly generate a 5-second clip in under 3 seconds.

Fal engineer Rehan Sheikh used that speed to build an endless livestream inspired by interdimensional cable. After Twitch and Kick removed it, fal launched its own platform:

https://fal.live/

The channels are continuously generated, and viewers can influence what happens next.

Pieter Levels also built Infinite Slop with fal:

https://infiniteslop.ai/

It is exactly what the name implies, but the feedback loop is interesting: audience prompt -> generated scene -> audience response -> next scene. 📺

The technical release underneath this is H3 Max Director:

https://fal.ai/h3-max-director

Unlike normal clip generation, Director keeps an active realtime session and carries context across segments. Fal's docs say public sessions currently run up to 2 minutes.

Current promo pricing is $0.02 per generated second, which makes continuous generation about $1,728/day.

I am not convinced infinite AI TV itself is the killer app, but a stateful video stream that can be redirected while it plays seems like a genuinely new primitive.

What would you actually build with that?

The project is an MoE-native serving engine that treats GPU, CPU, host RAM, and PCIe bandwidth as one inference platform. ⚡

Published paper results include:

Qwen3.6-35B-A3B
RTX 4060 Laptop 8GB
39.3 tok/s

DeepSeek-V4-Flash 284B
RTX 5090
22-25 tok/s

The full expert pool lives in system RAM and VRAM acts as an expert cache.

On cache misses, FreeToken can either transfer an expert to the GPU or execute it directly on the CPU, with the split chosen from measured bandwidth.

Important caveat: low VRAM does not mean low total memory. The host RAM still has to hold the expert weights.

https://github.com/FlashML-org/FreeToken

Current support is mainly x86_64 + NVIDIA RTX 30/40/50-series hardware.

Has anyone here benchmarked it against llama.cpp/Ollama on the same checkpoint and hardware? I would be interested in real-world agent workloads rather than short synthetic decode tests.