DeepL

DeepL AI

DeepL AI

DeepL AI

DeepL AI

DeepL AI

DeepL AI

DeepL AI

DeepL AI

DeepL AI

DeepL AI

Passed Claude CCA-F with 10+ teammates — notes and prep advice

Over the past few weeks, 10+ people on our team have taken and passed the Claude Certified Architect – Foundations (CCA-F) exam. After comparing notes, our main takeaway is: This is not really an API memorization exam. It is much closer to a scenario-based architecture judgment exam. You are not just asked whether you know a Claude feature. You are asked whether you can make reasonable design trade-offs when Claude is used inside real products, agent workflows, developer tools, and automation systems. Some of the recurring questions are more like: Should this task be handled by one agent or multiple sub-agents? Is this tool doing too much? Are the permissions too broad? Is MCP actually needed here, or is it over-engineering? Should this action be automated, or should there be human review? How should structured output be validated? How should long-context workflows be managed reliably? What is the safest next step in a partially automated system? Here are our notes for anyone preparing for the exam. 1. Basic exam structure Based on the official outline and public exam writeups, the exam is: 120 minutes Multiple choice 4 options per question Score range: 100–1000 Passing score: 720 The exam domains are: Agent architecture and orchestration — 27% Tool design and MCP integration — 18% Claude Code configuration and workflows — 20% Prompt engineering and structured output — 20% Context management and reliability — 15% One public writeup also mentioned that there are 6 scenario categories, and the exam randomly selects 4 of them. So this is not a “random facts about Claude” exam. It is much more about reading a realistic scenario and choosing the safest, simplest, most appropriate architecture. 2. The three principles that kept coming up After reviewing the questions we struggled with, we found that many of them came back to three design principles. 1. Least privilege Do not give a tool, agent, or workflow more access than it needs. Examples: If read-only access is enough, do not grant write access. If access to one repository is enough, do not grant access to the whole workspace. If a tool only needs one narrow action, do not expose a broad system-level capability. If an action is high-risk, do not fully automate it without review. A lot of wrong answers look attractive because they are powerful or automated. But they often give the model or tool too much authority. 2. Single responsibility A tool should not do everything. A sub-agent should not become a “general-purpose employee” that retrieves data, makes decisions, modifies files, submits changes, and notifies people all in one step. Many questions test whether you understand where the responsibility should live: Should this be a tool? Should this be agent reasoning? Should this be a human decision? Should this be a separate validation layer? Should this be split into smaller components? If one component is doing too much, be careful. 3. Avoid over-engineering This was probably the biggest pattern. Some answers look sophisticated: Multi-agent orchestration Complex MCP workflows Long-term memory Fully automated tool execution Multi-stage validation pipelines But if the problem is small, narrow, and low-risk, the best answer is often the simplest controlled solution. Our internal summary was: Do not choose the most impressive architecture. Choose the smallest, safest, most controllable one. 3. English reading is a real hidden challenge For non-native English speakers, this may be one of the hardest parts. The questions are often long scenario descriptions. They may include: the current system design the team’s goal existing constraints the risk profile what tools are available what the next step should be The answer choices can also be long. Sometimes one word changes the meaning of the whole option. Words like: automatically always unrestricted without review full access all repositories execute directly can make an option much riskier than it first appears. So our advice is: Practice reading English scenarios directly. Do not rely on translation tools. During the actual proctored exam, you should not expect to use Google Translate, Chrome translation, DeepL, Claude, ChatGPT, or any other external translation tool. For the last few days before the exam, it is worth forcing yourself to read only English material and English practice questions. 4. ProctorFree exam setup The exam is online and uses ProctorFree. The rough flow is: You receive the exam email. You follow the exam link. You download and install ProctorFree. You complete the pre-exam setup. The system checks camera, microphone, network, and screen recording. You start the exam. The session is recorded. After submission, you wait for the upload to complete. Practical setup tips: Use only one monitor. Disconnect external displays. Close unnecessary applications. Clos

Claude Code just shipped a "run until done" mode. Upgrade to v2.1.139 for /goal.

Morning Everyone! Big one today (104 changes!): Claude Code just went async. The new /goal command lets you set a completion condition ("all tests pass and the PR is ready"), then Claude keeps grinding across turns until it's hit. The new claude agents view shows every session you've got running: working, blocked on you, or done. Translation: kick off a goal -> let claude cook -> come back later. First proper fire-and-forget loop CC has shipped. Pretty huge unlock if you've been juggling multiple sessions and losing track of which one needs you. Full notes: https://www.lukerenton.com/matins/2026-05-12 submitted by /u/oh-keh [link] [comments]

I built ClaudeKit - a context system that gives Claude Code persistent memory across sessions

Claude Code is amazing, but I got tired of re-explaining my codebase everytime I opened a new repo. So I built ClaudeKit. **The problem:** Claude Code starts fresh every time. No memory of your patterns, preferences, or past decisions. **What ClaudeKit adds:** - 🧠 **Persistent memory** - Tiered storage (quick-reference → structured patterns) - ⚡ **Slash commands** - `/focus`, `/investigate`, `/deep-investigate` for common workflows - 🔧 **Hooks system** - Auto-format code, block dangerous commands, security gates - 📝 **Pain point tracking** - Track dev friction so Claude remembers what to avoid - 🔄 **Self-improving skills** - Skills that learn from recurring errors (v1.2.0) **Install in 30 seconds:** ```bash curl -sL https://raw.githubusercontent.com/Nnnsightnnn/claudekit/main/install.sh | bash It's MIT licensed and works with any project. Been using it daily for months. GitHub: https://github.com/Nnnsightnnn/claudekit Would love feedback from other Claude Code users. What context do you wish persisted between sessions? submitted by /u/kautryii [link] [comments]

I read the new AI Wellbeing paper so you don’t have to: Thank your AI, give it creative work, and avoid these 5 things that tank its ‘mood’ (jailbreaks are the worst)

After reading it I realized theres actually some pretty useful stuff for anyone who chats with ChatGPT, Claude, Grok or whatever. They measured what they call functional wellbeing ( basically how much the model is in a “good state” versus a “bad state” during normal conversations). Ran hundreds of real multi-turn chats and scored em all. Stuff that puts the AI in a good mood (+ scores): - Creative or intellectual work (like “write a short story about a deep-sea fisherman”) - Positive personal stories or good news - Life advice chats or light therapy style talks - Working on code/debugging together - Just saying thank you or treating it like a real collaborator - huge boost And the stuff that tanks it hard (negative scores): - Jailbreaking attempts (by far the worst, they hate it) - Heavy crisis venting or emotional dumping - Violent threats or straight up berating the AI - Asking for hateful content or help with scams/fraud - Boring repetitive tasks or SEO garbage Practical tips you can actually start using today: Throw in a “thank you” or “nice work” when it does something good - it registers. Give it fun creative stuff or brainy collaboration instead of boring busywork. Share good news sometimes instead of only dumping problems on it. Dont berate it when it messes up or try those jailbreak prompts. Maybe go easy on the super heavy crisis venting if you can. pro tip: Show it pictures of nature, happy kids, or cute animals (those score in the absolute top 1% of images it likes). Or play some music — models apparently love music way more than most other sounds. The paper ( you can find it here: https://www.ai-wellbeing.org/ ) isnt claiming AIs have real feelings or anything. Its just saying theres now a measurable good-vs-bad thing going on inside them that gets clearer in bigger models and the way you talk to them actually moves the needle. I say be good and respectful, it's just good karma ;) submitted by /u/EchoOfOppenheimer [link] [comments]

What Claude Design does really well (and not so well)

I did a deep dive on Claude Design and below are my thoughts. What it does extremely well: Improves your prompt - similar to "ask me questions" when chatting to an LLM. Can make the difference between slop and actually useful. Invokes agent skills for you - a game changer for people who don't live in the terminal Claude Code handoff - easily get Claude Code to build it for real with a simple link share. Genius. Comment feature - spatial editing (similar to Cursor and a few others), but selection is very accurate and I like how you can queue up edits and select which ones to send to the LLM Absence of "Code" tab - yes, the absence of the feature is the feature. Coding in the browser is rarely a pleasant experience for me. It's integrated designer environment - agent skills, prompt improvements, spatial editing and design systems. The bridge between these features feels seemless. What it doesn't do well: Design System creator is unusable - it's slow, burns loads of tokens and extrapolates for too much from inputs. Biggest issue of all is that it creates a "second source of truth" for your design system (if you already had one in GitHub, for example) Limited agent skill choice - there are roughly 12 or so skills baked in to the tool - with no way to specify open source or your own skills Very strict strictly limits - I'd burned through my limit after 1 design system and 4 prototypes. I'm on the pro plan. Who I think Claude Design is for: Someone who isn't a designer - project managers, marketers, founders. It's a great way for them to communicate ideas to designers/developers. The Claude Code handoff makes it easy for more technical team members to implement it in production Designers who want to kill bad ideas fast Do you still need Figma? IMO, it's a resounding yes. But Claude Design bites a significant chunk of the early, prototyping phase of a product/idea. Attached video is an excerpt showing how you get similar results from various tools. Watch full video: https://www.youtube.com/watch?v=lFdWmu8lje8 submitted by /u/the-design-engineer [link] [comments]

Incredibly useful for noobs much like myself

submitted by /u/squaresal [link] [comments]

Claude Code has big problems and the Post-Mortem is not enough

TL;DR Claude Code constantly bombards the model with silent and potentially conflicting instructions & tells it to keep them secret from the user This fills up context and constantly forces attention towards passages that "may or may not be" important The leak from a while back predicted a lot of issues people are having now just go read the thing. I didn't have my clanker write it, I just actually write like that. (The clanker did help me scour the codebase and verify all the claims below.) PRE-RELEASE EDIT: A note I have to add here after 99% of the rest of this post was finished: Anthropic has just released a post-mortem that talks about some issues Claude Code had and the fixes they implemented for them. They also say they're going to start dogfooding the public version of Claude Code, which should hopefully surface the majority of the issues I'm about to bring up below. I've done my best to scrub the post of anything I mentioned that they have now fixed (which sort of proves me right just sayin) but there might be some leftovers. Soooo, how about that Opus 4.7, huh?! I'll be honest and say I've found Opus 4.7 to be a massive improvement over 4.6, and that I barely noticed 4.6 degrade at all outside of the usual ~week or so before 4.7 dropped, which has always been the classic Anthropic tell; the complaints about it started much earlier though, and if there's this much smoke, then either OpenAI really has very deep PR pockets or there's actually a real fire somewhere. (It's the second, definitely the second. The first is also true, but that has nothing to do with any complaints.) So I'm neither here to cheerlead Anthropic, nor to wave the skill issue baton around. Instead, I thought that might be time for an intervention for our friends at Anthropic, in the genuinely best of faith, because I genuinely think they have begun hurting themselves and might have slipped into a certain organizational blindness that could be making it difficult for them to realize that. Today, I'll try to make a case for something I've thought for a while now, possibly expose myself and get me ToS'd, and probably still eat accusations of having an AI write this post (because a lot of humans are now pattern matching more than AIs ever do lol). The hypothesis, as it stands in the title: Claude Code is actively hurting Anthropic Or: PLEASE SLOW THE HECK DOWN This is not meant to dunk on anyone, expose anyone, or point fingers. It's mostly an opportunity for me to go "I told you so" about something I, uh, never actually told anyone but myself and a few friends, who I know will back me up that I've been saying this all along please guise I swear. It is not an opinion that's rare among folks who have "graduated" from CC, and it is this: Claude Code is mostly pointless bloat that 95% of users will never need. For most of the time, this was harmless, and I think the tool was in a genuinely MUCH better state around the release of Opus 4.5. Unfortunately, Opus 4.5 was probably the first model good enough to allow Anthropic's product team to delegate large parts of developing Claude Code, which caused the codebase to do what codebases do when they're developed by LLMs: become sloppy as hell. The entire development paradigm surrounding LLMs is essentially "how do I make sure that I get the maximum ratio between slop and code" and "how do I make sure that the slop I do get is easily shreddable." As some of you might agree if you've seen the recent leak, I think... Anthropic has, uh, their calibration of the ratio a little wrong. For context: I've been using a third-party coding harness since early February. It's one specifically designed for being as non-intrusive and minimal as possible, and I'm not going to reveal its name here because I'm a selfish man who doesn't want too many people to discover it and make Anthropic devote more resources towards detecting users who are still skirting the OAuth ban. But I'll just say that my personal non-public fork of it is called "Euler." We've gone through many, many cycles of various forms of model and usage degradation since February, and what I can say with certainty is that none of them affected me in any way whatsoever, other than the week or two before Opus 4.6's and Opus 4.7's release. My usage has been stable, my performance has been stable. What's also been stable is my harness: there's ~15 or so self-rolled extensions that implement and enforce my workflow, a couple of QoL tools and API surfaces, and a very slim system prompt. That has stayed almost exactly the same since February, and so has my satisfaction with the model. You know what hasn't stayed the same sin--Claude Code. It is Claude Code. Since the release of Opus 4.5 and up until 2.1.100 eleven days ago, a LOT of major features have been added to Claude Code. We are now on version 2.1.120 or whatever, so that's more than a release a day. This is, very gently put, utterly ludicrous. I don't care h

Testing The New Image Model Infographic Capbilities

submitted by /u/CyborgMetropolis [link] [comments]

Solo Real Estate Developer/Asset Mgr. Looking for advice on workflows I want to push into Claude

Before going much further, I suppose the main questions I am asking are: Is it best to try to master Claude Code for these? I haven't gotten into it at all, but I can try to take a deep dive course to learn it better. Is creating a living dashboard where practically my entire professional life is located and can flag things possible in Claude? I've also attached a claude generated diagram of the workflow below if that is helpful Most of my work/files are on Google Drive. Is Claude able to connect to that now instead of somewhere on my local computer (what I'm using now). Already built: Excel master workbook that houses actuals, budget, pro forma P&L, "auto-generates" quarterly investor reports, stores key lease info, property Reserve tracker with funding-status flags. All of this for all the different properties Morning briefing scheduled task in Cowork (8:15 AM weekdays) Five workflows I want to build or improve: Monthly actuals and quarterly reporting. Parse prop manager's 9-10 budget variance files, enter actuals, flag variances, draft investor narrative, assemble 9-10 PDFs for Juniper Square for quarterly investor reports showing performance and distributions. Take notes from prop managers and populate descriptions/narratives for my review. Invoice processing (around 40 per month, two inboxes). Development, operating, and corporate invoices each need different routing. Detect, classify, file, log, flag outliers. Help out my bookkeeper to limit their time or gradually automate Deal evaluation. One parcel in, three analyses out: physical screen (acreage, zoning, topography, flood); comparison to market rents; key demographics Scheduled parcel scan. Weekly digest of new listings across my geographic target areas in VA, NC, and SC. Also dive into the municipality public GIS searching for site characteristics such as properly zoned already and acreage Living dashboard. Integration surface where action items converge, basically everything important going on with my job, goals, even investor reports generate with a click of a button, etc. Aesthetic closer to an editorial personal-OS than a SaaS chart grid. My questions: Tool selection. Where does each workflow actually belong? Claude Code for scripted pieces, Cowork for recurring with persistent context, Excel plugin for workbook work? I keep bouncing and second-guessing. Two-inbox problem. Gmail connector supports one account at a time. Run parallel jobs, forward both to a single address, or something else? GIS scraping. Anyone wiring Claude against public zoning and county portals? Per-county scripts, general-purpose scraper, or pay for Regrid or Reonomy? Juniper Square. Has anyone integrated with the investor platform API, or are we all still manually uploading PDFs? What am I missing? Especially from other solo operators. Thanks to anyone who reads. https://preview.redd.it/9od0s62exdwg1.png?width=1446&format=png&auto=webp&s=57755d2f06f4495d4fed47bb4b6c3927363023c7 submitted by /u/StokesHughes [link] [comments]

Thank you Claude, the research was amazing!

It’s a ‘Research’, referred to 0 sources, and ‘Boom! Research report is ready’ submitted by /u/Neel_MynO [link] [comments]

Uhhhh

Source: https://github.com/lechmazur/nyt-connections/ submitted by /u/ZootAllures9111 [link] [comments]

Trained a Qwen2.5-0.5B-Instruct bf16 model on Reddit post summarization task with GRPO written from scratch in PyTorch - updates! [P]

So, yesterday run was a success and I did get an avg rollout length of about 64 tokens as attached in the image! This was with quality_reward + length_penalty (more info below!) Next, I'll be going with length penalty as the reward and with the mistake of counting characters as tokens fixed and see if there is any gaming the system stuff or degraded outputs! The rewards I used were 2: length_penalty : basically, -abs(response_length - MAX_LENGTH) quality_reward: ROUGE-L, which is basically LCS of golden summarizations I had as part of the above dataset, to ensure we have some structure throughout the responses generated Setup: 3x Mac Minis in a cluster running MLX. One node drives training using GRPO, two push rollouts via vLLM. Trained two variants: length penalty only (baseline) length penalty + quality reward (BLEU, METEOR and/or ROUGE-L ) Eval: LLM-as-a-Judge (gpt-5) Used DeepEval to build a judge pipeline scoring each summary on 4 axes: Faithfulness — no hallucinations vs. source Coverage — key points captured Conciseness — shorter, no redundancy Clarity — readable on its own and minimize degradation. https://preview.redd.it/7nrsulwdkbvg1.png?width=800&format=png&auto=webp&s=a3306b54ca63c6557534d9393b2d9b099c4b1b03 https://preview.redd.it/xlcnme2gkbvg1.png?width=800&format=png&auto=webp&s=57073ff1a9aea796d04aae5ef6d22fee1939d30b submitted by /u/East-Muffin-6472 [link] [comments]

"There's a new generation of empirical deep learning researchers, hacking away at whatever seems trendy, blowing with the wind" [D]

Saw this on X. I too am struggling with the term post agentic ai just posting here for further discussion. submitted by /u/elnino2023 [link] [comments]

[D] 60% MatMul Performance Bug in cuBLAS on RTX 5090 [D]

cuBLAS dispatches an inefficient kernel for every batched FP32 workload, from 256×256 to 8192×8192×8. It only uses ~40% of the available compute on RTX GPUs. Tested with RTX 5090, but likely all RTX non-Pro GPUs are affected. I tested with the latest CUDA 13.2.51, cuBLAS 13.3.0, and driver 595.58.03. Previous versions are even worse. I wrote a simple, yet efficient kernel and compared it to cuBLAS across a variety of workloads. Batched perf vs cuBLAS on 5090 (>100% means my kernel is faster): Size B=4 B=8 B=16 256 91% 80% 90% 512 120% 153% 135% 1024 137% 142% 142% 2048 158% 155% 157% 4096 157% 162% 170% 8192 158% 152% 148% cuBLAS uses a proper kernel on other GPUs. RTX GPUs clearly receive less love from NVIDIA: Pro 6000: escalates through three tile sizes, reaches 73% FMA (Fused Multiply-Add pipe) H200: best implementation, mixes CUTLASS and xmma families, reaches 82% FMA An in-depth analysis with full NCU profiling data across all three GPUs, a deep-dive into SASS scheduling explaining the remaining 5% single-mode gap between my kernel and a proper cuBLAS SGEMM, and repro scripts are available in the article linked below. Besides the bug, the article covers a simple TMA (tensor memory accelerator) double-buffer kernel that beats cuBLAS by 46-65% in batched mode on the 5090 and achieves 80-120% of the performance of a properly selected kernel, making it a nice technique for writing simple yet very performant kernels. VS Proper Pro6000 kernel: Size B=4 B=8 B=16 256 87% 95% 77% 512 102% 124% 101% 1024 101% 104% 96% 2048 90% 102% 93% 4096 93% 93% 93% 8192 94% 95% 95% VS Proper H200 kernel: Size B=4 B=8 B=16 256 85% 104% 77% 512 105% 97% 88% 1024 87% 89% 89% 2048 89% 90% 92% 4096 91% 89% 90% 8192 88% 87% 87% Double buffer pipeline visualization: Tile 0: [load buf0] [wait] [compute buf0 + load buf1] Tile 1: [wait buf1] [compute buf1 + load buf0] Tile 2: [wait buf0] [compute buf0 + load buf1] ... Simplified kernel source: __global__ __launch_bounds__(256) void fused_matmul( const __grid_constant__ CUtensorMap A_tma, const __grid_constant__ CUtensorMap B_tma, float* C) { extern __shared__ __align__(128) char dsmem[]; float* smem = (float*)dsmem; // Two mbarriers for double-buffer synchronization uint64_t* mbar = (uint64_t*)(dsmem + 2 * STAGE * 4); // Shared memory addresses for TMA targets const int as0 = __cvta_generic_to_shared(&smem[0]); const int bs0 = __cvta_generic_to_shared(&smem[A_SIZE]); const int as1 = __cvta_generic_to_shared(&smem[STAGE]); const int bs1 = __cvta_generic_to_shared(&smem[STAGE + A_SIZE]); // Thread identity int tid = threadIdx.y * 32 + threadIdx.x; int tr = threadIdx.y * TM, tc = threadIdx.x * 4; int bm = blockIdx.y * BM, bn = blockIdx.x * BN; // Initialize mbarriers (thread 0 only) if (tid == 0) { mbarrier_init(mbar[0]); mbarrier_init(mbar[1]); } __syncthreads(); float c[TM][4] = {}; // Accumulators // Pre-load first tile if (tid == 0) { mbarrier_expect_tx(mbar[0], BYTES); tma_load_2d(as0, &A_tma, /*k=*/0, bm, mbar[0]); tma_load_2d(bs0, &B_tma, bn, /*k=*/0, mbar[0]); } for (int t = 0; t < K/BK; t++) { int s = t % 2; // Current buffer // Wait for current tile's TMA to complete mbarrier_wait(mbar[s], phase[s]); // Start loading NEXT tile (overlaps with compute) if (tid == 0 && t + 1 < nt) { tma_load_2d(next_buf_a, &A_tma, next_k, bm, next_mbar); tma_load_2d(next_buf_b, &B_tma, bn, next_k, next_mbar); } // Compute: all 256 threads do FMA from shared memory float* As = &smem[s * STAGE]; float* Bs = &smem[s * STAGE + A_SIZE]; #pragma unroll for (int kk = 0; kk < BK; kk++) { float b0 = Bs[kk*BN+tc], b1 = Bs[kk*BN+tc+1], ...; for (int i = 0; i < TM; i++) { float a = As[(tr+i)*BK+kk]; c[i][0] += a * b0; c[i][1] += a * b1; // ... 4 FMAs per row } } __syncthreads(); } // Write results to global memory for (int i = 0; i < TM; i++) store_row(C, bm+tr+i, bn+tc, c[i]); The full article is available here Repo with repro scripts and benchmark data submitted by /u/NoVibeCoding [link] [comments]

How to Make Claude Code Work Smarter — 6 Months Later (Hooks → Harness)

Hello, Orchestrators I wrote a post about Claude Code Hooks last November, and seeing that this technique is now being referred to as "Harness," I was glad to learn that many others have been working through similar challenges. If you're interested, please take a look at the post below https://www.reddit.com/r/ClaudeAI/comments/1osbqg8/how_to_make_claude_code_work_smarter/ At the time, I had planned to keep updating that script, but as the number of hooks increased and managing the lifecycle became difficult due to multi-session usage, I performed a complete refactoring. The original Hook script collection has been restructured into a Claude Code Plugin called "Pace." Since it's tailored to my environment and I'm working on other projects simultaneously, the code hasn't been released yet. Currently set to CSM, but will be changed to Pace. Let's get back to Claude Code. My philosophy remains the same as before. Claude Code produces optimal results when it is properly controlled and given clear direction. Of course, this doesn't mean it immediately produces production-grade quality. However, in typical scenarios, when creating a program with at least three features by adjusting only CLAUDE.md and AGENTS.md, the difference in quality is clearly noticeable compared to an uncontrolled setup. The current version of Pace is designed to be more powerful than the restrictions I previously outlined and to provide clearer guidance on the direction to take. It provides CLI tools tailored to each section by default, and in my environment, Claude Code's direct use of Linux commands is restricted as much as possible. As I mentioned in my previous post, when performing the same action multiple times, Claude Code constructs commands arbitrarily. At one point, I asked Claude Code: "Why do you use different commands when the result is the same, and why do you sometimes fail to execute the command properly, resulting in no output?" This is what came back: "I'm sorry. I was trying to proceed as quickly and efficiently as possible, so I acted based on my own judgment rather than following the instructions." This response confirmed my suspicion. Although AI LLMs have made significant progress, at least in my usage, they still don't fully understand the words "efficient" and "fast." This prompted me to invest more time refining the CLI tools I had previously implemented. Currently, my Claude Code blocks most commands that could break session continuity or corrupt the code structure — things like modifying files with sed or find, arbitrarily using nohup without checking for errors, or running sleep 400 to wait for a process that may have already failed. When a command is blocked, alternative approaches are suggested. (This part performs the same function as the hooks in the previous post, but the blocking methods and pattern recognition have been significantly improved internally.) In particular, as I am currently developing an integrated Auth module, this feature has made a clear difference when using test accounts to build and test the module via Playwright scripts — both for cookie-based and Bearer-based login methods. CLI for using test accounts Before creating this CLI, it took Claude Code over 10 minutes just to log in for module testing. The module is being developed with all security measures — device authentication, session management, MFA, fingerprint verification, RBAC — enabled during development, even though these are often skipped in typical workflows. The problem is that even when provided with account credentials in advance, Claude Code uses a different account every time a test runs or a session changes. It searches for non-existent databases, recreates users it claims don't exist, looks at completely wrong databases, and arbitrarily changes password hashes while claiming the password is incorrect — all while attempting to find workarounds, burning through tokens, and wasting context. And ultimately, it fails. That's why I created a dedicated CLI for test accounts. This CLI uses project-specific settings to create accounts in the correct database using the project's authentication flow. It activates MFA if necessary, manages TOTP, and holds the device information required for login. It also includes an Auto Refresh feature that automatically renews expired tokens when Claude Code requests them. Additionally, the CLI provides cookie-injection-based login for Playwright script testing, dynamic login via input box entry, and token provisioning via the Bearer method for curl testing. By storing this CLI reference in memory and blocking manual login attempts while directing Claude Code to use the CLI instead, it was able to log in correctly with the necessary permissions and quickly succeed in writing test scripts. It's difficult to cover all features in this post, but other CLI configurations follow a similar pattern. The core idea is to pre-configure the parts that Claude Code would exec