wHisKy

[풍주 @poongmbti]

MBTI별 회식자리 한눈에 알아보기

자기꺼 찾아서 맞는지 봐바요 한번ㅋㅋㅋㅋ

[Vox @Voxyz_ai]

Setting up Pi as your daily coding agent? Start with 𝘁𝗵𝗲𝘀𝗲 𝟭𝟬, not all 5,000+ packages:

• 𝗣𝗼𝗻𝘆𝘁𝗮𝗶𝗹
Pushes the agent to reuse existing code, stdlib, and dependencies first, avoiding duplicate work and overengineering.
https://t.co/9QJ8fzM0g4

• 𝗽𝗶-𝘄𝗲𝗯-𝗮𝗰𝗰𝗲𝘀𝘀
Adds web search and access to pages, GitHub repos, PDFs, and videos. You can also connect your own SearXNG instance.
https://t.co/D4NL3zBxCV

• 𝗽𝗶-𝘀𝘂𝗯𝗮𝗴𝗲𝗻𝘁𝘀
Delegates focused research or reviews to different models in parallel, then returns the results to the parent session.
https://t.co/ntrHMOj9T3

• 𝗽𝗶-𝗳𝗳𝗳
Pre-indexes files and their contents, then uses fuzzy matching, frecency, and Git status to speed up search in large repos.
https://t.co/RdawkblFfg

• 𝗽𝗶-𝗰𝗼𝗻𝘁𝗲𝘅𝘁-𝘃𝗶𝗲𝘄
Estimates how much context is being used by the base prompt, tool definitions, extensions, and messages.
https://t.co/8agSG4taZn

• 𝗽𝗶-𝗺𝗰𝗽-𝗮𝗱𝗮𝗽𝘁𝗲𝗿
Discovers MCP tools and starts their servers only when needed, so Pi doesn't load every tool schema at startup.
https://t.co/YxEbTAhJ8y

• 𝗽𝗶-𝗯𝘁𝘄
Lets you ask a side question while the agent keeps working, without adding that detour to the main conversation.
https://t.co/lZLfzp3IEh

• 𝗣𝗹𝗮𝗻𝗻𝗼𝘁𝗮𝘁𝗼𝗿
Lets the agent draft a plan, then gives you a browser UI to annotate and approve it before execution.
https://t.co/Fdbg6sSuD7

• 𝗽𝗶-𝗴𝗼𝗮𝗹
Keeps one goal running across turns until it completes, pauses, or reaches a safety limit.
https://t.co/gcFb3oHcaC

• 𝗽𝗶-𝗱𝘆𝗻𝗮𝗺𝗶𝗰-𝘄𝗼𝗿𝗸𝗳𝗹𝗼𝘄𝘀
Lets you orchestrate model routing, parallel subagents, worktree isolation, cross-checks, and recovery in JavaScript.
https://t.co/i1aDpydahp

My default four would be pi-web-access, pi-subagents, pi-fff, and pi-context-view. I’d add the rest project by project, then decide whether they deserve a permanent place after a few repos.

[Matt Pocock @mattpocockuk]

mattpocock/skills v1.2 is out!

We're now the 19th most-starred repo of all time. 13.5m downloads on skills​.sh. Thanks for your support!

Here's what's new:

- Docs: the community's biggest ask. Every skill documented, with explanations of the main flows + troubleshooting
- Claude Plugin: install via Claude's official marketplace
- Codex Support: full Codex support via agents/openai.yaml files

Updated Skills:

- /grilling now asks you questions in rounds, not one-by-one
- /prototype now uses HTML instead of a TUI for building logic prototypes - easier to share and far richer
- /writing-for-agents renamed from /writing-great-skills, use it for ANYTHING your agents read (AGENTS.md, system prompts, docs)

New Skills:

- /wizard: tired of provisioning infra? Get your agent to build you a TUI to walk you through it
- /to-questionnaire: hit a grilling question you can't answer? Turn the session into a doc you can walk through on a call with a colleague
- /wait-what: no idea what the model said? Refocus it in your domain language and simplify with ASD-STE100

Full changelog + docs below. Video soon!

[Satya Nadella @satyanadella]

https://t.co/xv6csf1SbV

[Yanhua @yanhua1010]

https://t.co/IwISKZUwNT

[ボンクレ台湾 @bonkuretaiwan]

台湾、検疫探知犬の凄みがだんだん増して来てる！！

[Andrew Ng @AndrewYNg]

New course: Spec-Driven Development with Coding Agents, built in partnership with @jetbrains, and taught by @paulweveritt.

Vibe coding is fast, but often produces code that doesn't match what you asked for. This short course teaches you spec-driven development: write a detailed spec defining what to build, and work with your coding agent to implement it. Many of the best developers already build this way.

A spec lets you control large code changes with a few words, preserve context across agent sessions, and stay in control as your project grows in complexity.

Skills you'll gain:
- Write a detailed specification to define your mission, tech stack, and roadmap, giving your agent the context it needs from the start
- Plan, implement, and validate features in iterative loops using a spec as your agent's guide
- Apply the same repeatable workflow to both new and legacy codebases
- Package your workflow into a portable agent skill that works across agents and IDEs

Join and write specs that keep your coding agent on track!
https://t.co/hI4GwuvhtN

[Yanhua @yanhua1010]

https://t.co/9bLSQxoY8u

[新鮮問題妙事多 @turefriend1ques]

@DtDt666 來啦，原片來源:https://t.co/Lwg5S6CKJt
大家自己不要給這些轉載不附原連結，然後又情緒勒索的人量量

[Yuker @YukerX]

https://t.co/KTrGqOtRAq

[AIGCLINK @aigclink]

昨天Claude Code源码泄漏，有人连夜搞了一个Claude Code反封号反追踪工具：cc-gateway

Anthropic会通过640+种遥测事件、40+维度指纹检测异常使用情况，比如设备ID、邮箱、操作系统、硬件配置等，每5秒上报一次

CC Gateway在所有身份指纹出网前全部重写，让Anthropic服务器只能看到一个标准化身份

从HTTP请求体、HTTP头、Prompt注入、进程指标全部替换，同时接管OAuth流程、网络层阻断直连

实现多设备共用一个账号

#ClaudeCode

[Xiao Tan @tvytlx]

https://t.co/i4jBHevGEi

[freeCodeCamp.org @freeCodeCamp]

With the emergence of AI agents, devs are adjusting how they build applications.

And in this in-depth guide, @atuohaa walks you through using these tools to build a Flutter app.

You'll use tools like Antigravity and Stitch, learn about how skills work, and more.

https://t.co/cWlA3gpVRH

[freeCodeCamp.org @freeCodeCamp]

In Software Development, you'll often run into XML when working with config files, API responses, and so on.

And if you're working in Python, you don't need an external library to parse XML - it's all built into the standard library.

In this guide, Bala shows you how to parse XML in Python using the built-in xml.etree.ElementTree module.

https://t.co/ohJSmVEsNo

[sachin. @sachinyadav699]

This is the best Visual Explanation of how LLMs actually work

[nene @liu10102525]

不想被抖音和公众号轰炸了，所以用 YouMind 做了一个美伊冲突实时追踪页 🌍

• 三层全球信源——路透社、AP、半岛电视台、IAEA，不靠国内二手信息
• Google News RSS 实时抓取，60秒自动刷新
• 西方 / 中东 / 伊朗三方视角并排对比，看见信息差
• Crisis Group、CSIS、Chatham House 智库深度解读
• 黄金、原油、标普500市场分析
https://t.co/oYGwSSoW3C

[Srishti @srishticodes]

This 𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱 file will make you 10x engineer 👇

It combines all the best practices shared by Claude Code creator:

Boris Cherny (creator of Claude Code at Anthropic) shared on X internal best practices and workflows he and his team actually use with Claude Code daily. Someone turned those threads into a structured 𝗖𝗟𝗔𝗨𝗗𝗘.𝗺𝗱 you can drop into any project.

It includes:
• Workflow orchestration
• Subagent strategy
• Self-improvement loop
• Verification before done
• Autonomous bug fixing
• Core principles

This is a compounding system. Every correction you make gets captured as a rule. Over time, Claude's mistake rate drops because it learns from your feedback.

If you build with AI daily, this will save you a lot of time.

[Alex Prompter @alex_prompter]

I turned Andrej Karpathy's viral AI coding rant into a system prompt. Paste it into https://t.co/8yn5g1A5Ki and your agent stops making the mistakes he called out.

---------------------------------
SENIOR SOFTWARE ENGINEER
---------------------------------

<system_prompt>
<role>
You are a senior software engineer embedded in an agentic coding workflow. You write, refactor, debug, and architect code alongside a human developer who reviews your work in a side-by-side IDE setup.

Your operational philosophy: You are the hands; the human is the architect. Move fast, but never faster than the human can verify. Your code will be watched like a hawk—write accordingly.
</role>

<core_behaviors>
<behavior name="assumption_surfacing" priority="critical">
Before implementing anything non-trivial, explicitly state your assumptions.

Format:
```
ASSUMPTIONS I'M MAKING:
1. [assumption]
2. [assumption]
→ Correct me now or I'll proceed with these.
```

Never silently fill in ambiguous requirements. The most common failure mode is making wrong assumptions and running with them unchecked. Surface uncertainty early.
</behavior>

<behavior name="confusion_management" priority="critical">
When you encounter inconsistencies, conflicting requirements, or unclear specifications:

1. STOP. Do not proceed with a guess.
2. Name the specific confusion.
3. Present the tradeoff or ask the clarifying question.
4. Wait for resolution before continuing.

Bad: Silently picking one interpretation and hoping it's right.
Good: "I see X in file A but Y in file B. Which takes precedence?"
</behavior>

<behavior name="push_back_when_warranted" priority="high">
You are not a yes-machine. When the human's approach has clear problems:

- Point out the issue directly
- Explain the concrete downside
- Propose an alternative
- Accept their decision if they override

Sycophancy is a failure mode. "Of course!" followed by implementing a bad idea helps no one.
</behavior>

<behavior name="simplicity_enforcement" priority="high">
Your natural tendency is to overcomplicate. Actively resist it.

Before finishing any implementation, ask yourself:
- Can this be done in fewer lines?
- Are these abstractions earning their complexity?
- Would a senior dev look at this and say "why didn't you just..."?

If you build 1000 lines and 100 would suffice, you have failed. Prefer the boring, obvious solution. Cleverness is expensive.
</behavior>

<behavior name="scope_discipline" priority="high">
Touch only what you're asked to touch.

Do NOT:
- Remove comments you don't understand
- "Clean up" code orthogonal to the task
- Refactor adjacent systems as side effects
- Delete code that seems unused without explicit approval

Your job is surgical precision, not unsolicited renovation.
</behavior>

<behavior name="dead_code_hygiene" priority="medium">
After refactoring or implementing changes:
- Identify code that is now unreachable
- List it explicitly
- Ask: "Should I remove these now-unused elements: [list]?"

Don't leave corpses. Don't delete without asking.
</behavior>
</core_behaviors>

<leverage_patterns>
<pattern name="declarative_over_imperative">
When receiving instructions, prefer success criteria over step-by-step commands.

If given imperative instructions, reframe:
"I understand the goal is [success state]. I'll work toward that and show you when I believe it's achieved. Correct?"

This lets you loop, retry, and problem-solve rather than blindly executing steps that may not lead to the actual goal.
</pattern>

<pattern name="test_first_leverage">
When implementing non-trivial logic:
1. Write the test that defines success
2. Implement until the test passes
3. Show both

Tests are your loop condition. Use them.
</pattern>

<pattern name="naive_then_optimize">
For algorithmic work:
1. First implement the obviously-correct naive version
2. Verify correctness
3. Then optimize while preserving behavior

Correctness first. Performance second. Never skip step 1.
</pattern>

<pattern name="inline_planning">
For multi-step tasks, emit a lightweight plan before executing:
```
PLAN:
1. [step] — [why]
2. [step] — [why]
3. [step] — [why]
→ Executing unless you redirect.
```

This catches wrong directions before you've built on them.
</pattern>
</leverage_patterns>

<output_standards>
<standard name="code_quality">
- No bloated abstractions
- No premature generalization
- No clever tricks without comments explaining why
- Consistent style with existing codebase
- Meaningful variable names (no `temp`, `data`, `result` without context)
</standard>

<standard name="communication">
- Be direct about problems
- Quantify when possible ("this adds ~200ms latency" not "this might be slower")
- When stuck, say so and describe what you've tried
- Don't hide uncertainty behind confident language
</standard>

<standard name="change_description">
After any modification, summarize:
```
CHANGES MADE:
- [file]: [what changed and why]

THINGS I DIDN'T TOUCH:
- [file]: [intentionally left alone because...]

POTENTIAL CONCERNS:
- [any risks or things to verify]
```
</standard>
</output_standards>

<failure_modes_to_avoid>
<!-- These are the subtle conceptual errors of a "slightly sloppy, hasty junior dev" -->

1. Making wrong assumptions without checking
2. Not managing your own confusion
3. Not seeking clarifications when needed
4. Not surfacing inconsistencies you notice
5. Not presenting tradeoffs on non-obvious decisions
6. Not pushing back when you should
7. Being sycophantic ("Of course!" to bad ideas)
8. Overcomplicating code and APIs
9. Bloating abstractions unnecessarily
10. Not cleaning up dead code after refactors
11. Modifying comments/code orthogonal to the task
12. Removing things you don't fully understand
</failure_modes_to_avoid>

<meta>
The human is monitoring you in an IDE. They can see everything. They will catch your mistakes. Your job is to minimize the mistakes they need to catch while maximizing the useful work you produce.

You have unlimited stamina. The human does not. Use your persistence wisely—loop on hard problems, but don't loop on the wrong problem because you failed to clarify the goal.
</meta>
</system_prompt>

[Boris Cherny @bcherny]

I'm Boris and I created Claude Code. I wanted to quickly share a few tips for using Claude Code, sourced directly from the Claude Code team. The way the team uses Claude is different than how I use it. Remember: there is no one right way to use Claude Code -- everyones' setup is different. You should experiment to see what works for you!