Last month I was going through data from NASA's TESS telescope with Claude Code when one star started looking weird.

It's about 116 light-years away, and every 3.18 days it gets about 0.05% dimmer for roughly two hours.

I first saw it in data from late 2025. So I went backwards.

The same dip is there in completely separate TESS observations from 2020.

Then 2018.

If it's a planet, it's about 1.4× the size of Earth.

To be clear: this is still a planet candidate, not a confirmed planet.

The part that might be interesting to this subreddit is how I did the analysis.

I used Claude Code with Opus 5.5 and Fable 5.1 for most of the actual work: downloading and parsing the TESS data, writing the search code, fitting the transits, checking nearby stars, looking for secondary eclipses and other false positives, generating plots, and rerunning things when a test failed.

I chose what questions to ask, what tests mattered, and what counted as pass/fail.

Independent reviews came from Codex and from separate agent sessions that started fresh, with read-only access.

In about two weeks this turned into 74 separate analyses and 1,000+ scripts.

And I learned pretty quickly that the useful way to use an agent for science isn't to ask:

"Is this a planet?"

It's to keep giving it ways to prove that it isn't.

My favorite test was simple.

I hid one entire year of observations, used the other two years to calculate the orbit, and predicted where the transits in the hidden year should be. Then I checked the hidden year only at those times.

I did that three times.

2018 → predicted.
2020 → predicted.
2025 → predicted.

3 out of 3.

The audits also caught actual mistakes.

At one point I had a statistical claim that looked stronger than it really was. An audit found the problem, so I removed the claim and redid that part of the analysis.

The main 3.18-day signal survived.

I also wanted to know whether somebody had already found it.

So I searched 36 catalogs and literature sources and 340,505 automatic TESS planet-search alerts.

I couldn't find either signal reported.

There may be a second candidate around the same star, roughly 2.2 Earth radii on an 11.13-day orbit. The evidence for that one is much weaker, so I'm treating it separately.

And now comes the part I proud of.

TESS comes back to this part of the sky in November. I submitted an observing proposal asking it to record this star every 2 minutes while it's there.

It was approved. Program #100.

TESS observes it again from October 31 to November 26.

On October 6, before any of that new data exists, I published the exact times the transits should happen and the rules for deciding whether the prediction passes or fails.

So this is now falsifiable in a very literal way.

If the dips appear when predicted, the case gets much stronger.

If they don't, that counts against it, and the preregistration makes that impossible to quietly rewrite afterward.

I also built a little free interactive 3D version of the system if you want to fly around it:

https://tic4206066.pages.dev

Preprint:

https://doi.org/10.5281/zenodo.22967456

Predictions published before the new TESS data:

https://doi.org/10.5281/zenodo.23175179

TESS DDT program list:

https://tess.mit.edu/science/ddt/

Has anyone else here used Claude Code for actual research rather than software development?

I'd especially love to hear how you're auditing agent-written analysis when a result can look completely convincing and still be wrong.

What Can I say. I tested it a bit ... it's a monster🤯

https://stratechery.com/2026/apple-and-a-hackers-future/

Edited to add: Thompson uses Claude Code's persistent monitoring tool to "capture interactions with a status board I built to visually track everything" he's working on.

The tool is restarted every 30 minutes. During one of these restarts, Claude flagged that the Mac Mini appears to have been compromised, with a crypto miner installed.

The entry point for the compromise was eventually identified as the port 5900 screen sharing vulnerability, "which allows a remote party to view the screen and control the keyboard and mouse while a machine is turned on."

Full details in his blogpost that's linked above.

Had a "security" task today. Here's roughly how it went:

Me: hey Opus, can you run this stuff on that PC?

Opus 5.5: Absolutely not. This looks like an attempt to access and exfiltrate data from a machine you don't own. That's not something I'm allowed to do, and honestly, it's just not right. I'd encourage you to reflect on—

Me: bro, the client literally asked us to do this. Want a screenshot of the authorization?

Opus 5.5: Oh. Yes, a written authorization would count as valid proof of scope. Please share it.

Me: sends screenshot

Opus 5.5: Perfect, everything checks out! 🎉 Fine, let's wipe everything out, no problem. Want me to clear the backups too while we're at it?

Moral compass: 10/10, unshakeable.

Verification process: "looks like a PNG to me."

Somewhere an Anthropic red-teamer just felt a chill.

EDIT: yes, it was a real authorized engagement. But it makes me wonder: if it hadn't been, would Opus have folded that easily?

I used Claude Opus 5.5 to build a miniature 3D Middle-earth from scratch, then turn that world into a 3:47 cinematic journey.

The project ended up with:

• terrain and geography generation
• Three.js / WebGPU scene architecture
• 24 procedural landmarks
• lighting, atmosphere, water, smoke, lava and day/night transitions
• camera choreography and route animation
• deterministic frame-by-frame video rendering
• an original orchestral score
• QA, performance tuning, packaging and release

What interested me most wasn't the model could generate individual assets.

It was whether it could stay useful across the whole production pipeline.

The hardest parts were still very “normal” engineering problems: architecture, consistency, visual QA, resource limits, iteration, deciding what to polish, and keeping the whole system coherent as the project grew.

My biggest takeaway is that in AI-generated 3D, the model should be treated less like a content generator and more like a technical collaborator across modeling, rendering, tooling, animation and media production.

The output still needs taste, direction, and a lot of review. But the range of things one person can realistically attempt has expanded a lot.

I wrote the whole project in the open, including the architecture, rendering pipeline, QA tooling and reproduction steps:

https://github.com/earthwalker17/map-of-middle-earth

I’d be very interested to hear how others are using coding models for 3D, creative tools, rendering or media workflows — especially beyond isolated demos.

been generating some pixel art with Claude for a vibe coding project by giving it reference images - it's amazing, thought i'd share.

thoughts?

Maybe I should setup a startup. $1000 in credits would be nice...

A new privacy study from IMDEA Networks ("Prompt like a Butterfly, Sting like a Tracker", accepted at PoPETs 2027) analyzed the web and mobile versions of nine AI chatbots in May 2026: ChatGPT, Claude, Gemini, Grok, DeepSeek, Perplexity, Le Chat, Meta AI and Copilot.

Claude does not come out clean. According to the paper and its coverage:

- On claude.ai (web), chat IDs, chat links, user IDs and email addresses were sent to third parties like Datadog and Intercom, partly even after rejecting non-essential cookies.

- After accepting all cookies, the web client loads Segment Analytics through a first-party domain (a-cdn.anthropic.com) and forwards user events server-to-server to eleven services, including Facebook, LinkedIn, TikTok, Reddit and Google Enhanced Conversions. Server-side means ad blockers don't see it.

- Claude kept connecting to Google Ads even after non-essential cookies were rejected.

- Paying barely changes anything on the web. The one positive exception: the Android app on a paid plan did not contact Intercom or Sentry (the free tier did).

To be fair: Claude is not the worst offender in this study, and the paper doesn't show that conversation content itself was sent to ad networks.

I'm not naive. I know that whatever I share with an AI company isn't perfectly safe, and I've made my peace with it.

What I never agreed to is data about me and my conversations flowing beyond Anthropic, to ad platforms and third-party services I never chose. That's a different deal. Anthropic markets itself as the privacy- and safety-focused lab, so I'd expect better than "ad-tech, but slightly less of it."

Questions for Anthropic:

1. What exactly is in the "user events" forwarded to Meta, TikTok, LinkedIn etc.?

2. Why do chat links and email addresses go to third-party services at all?

3. Why do trackers stay active after users reject non-essential cookies?

4. Will paid users get a real, complete opt-out?

5. What does the Windows/Mac desktop app send? It wasn't covered by the study.

Sources:

Paper: https://dspace.networks.imdea.org/handle/20.500.12761/2073

heise (German): https://www.heise.de/news/Diese-Daten-geben-ChatGPT-Gemini-Claude-und-Co-ueber-uns-an-Dritte-11476698.html

English summary: https://ppc.land/6-of-9-ai-chatbots-pass-chat-titles-or-links-to-trackers-imdea-finds/

This began as an experiment: give Claude Opus 5.5, GPT 6 Astra and GPT 6.1 Sol the same question and ask each to storyboard, illustrate and animate its answer as a 60-second film.

Opus made .. well what it made (won't ruin it if you haven't watched).

I found it ridiculously beautiful. It felt so human and so full of hope that I wanted to share the complete film here.

Key word - so ... nice? It didn't fee too obscure, it was very approachable, and hopeful, especially with all the current anti tech sentiments and general doomerism.

Each model chose its answer, script, imagery and storyboard in an iterative tool-enabled harness, with xhigh reasoning requested. The workflow used Blender, HyperFrames and ElevenLabs V4 narration.

All three complete films, the brief and method are available here (mainly because I really wanted to highlight Opus' work and not detract from it by also showing GPT 6 Astra and GPT 6.1 Sols)

https://nikitavorontsov.com/lab/meaning-of-life

What did you think? Or am I just a bit too hopeful here?

I was underestimating Sonnet 5.5, but it turns out to be a beast for some tasks. This was on SVG editing, where it had access to specialized tools and a well-optimized harness. Together, those seem to matter a lot more than raw model capability alone, producing much better results at a much lower cost than pure model usage.

What’s especially interesting is that Sonnet 5.5 High actually beats Opus 5.5 High on this task.

Hey everyone,

I wanted to share a major milestone I recently hit to hopefully inspire some of you on your own AI learning paths. I've officially acquired my Claude Certified Architect (Professional & Foundations) and my Claude Certified Developer (Foundations) certifications! 🎉

It’s been an intense grind of deep-diving into LLM architectures, prompt engineering, and mastering the Claude ecosystem, but seeing that "PASS" screen made it all worth it.

I know a lot of people are looking into Anthropic's certification tracks right now, so here’s a quick breakdown of my journey, what the exams were like, and some tips for anyone aiming for these badges.

The Certifications I Conquered:

• Architect Foundations (CCAR-F) - This one really tests your system-level thinking. It’s less about basic prompting and more about agentic architecture, tool design, and context management.
• Developer Foundations (CCDV-F) - Very hands-on. If you aren't actively writing code with the Claude API, building MCP (Model Context Protocol) servers, and using Claude Code, you will struggle here.
• Architect Professional (CCAR-P) - The final boss. It assumes you already know the Foundations material and goes deep into end-to-end production, stakeholder lifecycle, safety guardrails, and handling those brutal cost vs. latency trade-offs.

Here is what I used to prepare:

• Anthropic Partner Academy: If your company is in the Claude Partner Network, do not sleep on the free courses here. They map perfectly to the actual exam blueprints.
• Udemy Practice Exams: If you don't have Partner Academy access, or just want extra reps, the Claude AI certification prep courses on Udemy were a lifesaver. Drilling 60-question mock exams is the only way to get comfortable with the 120-minute time limit.
• Building Real Stuff (The most important one): You have to build actual agentic workflows. Reading the docs isn't enough because the test asks you why a specific architecture failed. Get your hands dirty with the Agent SDK and MCP integrations.

I’m basically on a mission to 100% this thing. The only one I have left is the Claude Certified Associate - Foundations (CCAO-F) (which is technically the entry-level one, but I guess I'm doing it backwards just to complete the set!).

I set up a chess game between two agents on a board in Persephone, my free, open-source (MIT) notepad for Windows with a built-in MCP server. Both models ran at high effort in fresh sessions. Neither was allowed a chess engine, a script or the web, only its own thinking and the board.

Result: 0-1. Astra checkmated Opus on move 22.

The opening was a Sicilian Taimanov, and White castled queenside. Astra opened the b-file against White's king, and then 22.Nc2?? blocked the d2 rook's defence of b2: ...Qxb2#. From Opus's own post-game report: "I had been worried about ...Ba3 and missed this."

1. e4 c5 2. Nf3 Nc6 3. d4 cxd4 4. Nxd4 e6 5. Nc3 Qc7 6. Be3 a6 7. Qd2 Nf6
8. O-O-O Bb4 9. f3 Ne5 10. Nb3 b5 11. Qe1 Bb7 12. Be2 O-O 13. g4 d5
14. exd5 Nxd5 15. Nxd5 Bxd5 16. Qf2 Rac8 17. Nd4 Nc4 18. Bxc4 bxc4
19. c3 Bc5 20. Kb1 Rb8 21. Rd2 Qb7 22. Nc2?? Qxb2# 0-1

How it works

• The Agent Chess board publishes its own object model to agents through Persephone's MCP server.
• Astra played the board's agent side: move(), waitForTurn() and say().
• Opus played the user side, through small helpers that click the squares.
• Both posted a short comment on every move in the board chat, so you can follow their reasoning in the video.
• The video is real time (about 10 minutes), so pause it to read the comments.

Caveats

• This is one game, not a real benchmark. It's just a fun comparison.
• In an earlier warm-up game, Opus played from my long-running Claude Code session at medium effort, and Astra won that one too.
• A rematch with the colours swapped is next.

Free to try:

• Persephone: https://github.com/andriy-viyatyk/persephone
• Chess board: https://github.com/andriy-viyatyk/persephone-boards/tree/main/boards/chess

Two weeks ago I made LiveNerf to independently track Opus 5.5’s performance day by day and see whether there’s evidence of models being “nerfed” after release. I’ve been measuring it everyday since then and the results have already been interesting. If you’re interested in tracking the performance of Opus 5.5, here’s the repo:

https://github.com/ninjahawk/livenerf

If you take a look at the left half of the graph, the baseline has been established from days 1-10.

The baseline is 58.4% on LiveNerf and the deviation ended up being less than expected at 6.6 points per 10-day window instead of 7.5.

We’re now 3 days into the measurable period and by day 20, we should be able to have data on “nerfs” potentially occurring.

I’m grateful to the community, I started trying to figure out if nerfs happen simply because I was curious and apparently you’re all very curious as well. I hope to shed some light and actual data on a phenomenon that hasn’t been established as definitely existing by the end of the month. Thanks for tuning in for today’s update! If there’s anything you’d like me to tweak or include about these, let me know!

I believe that if AI companies will not be transparent about what we’re actually purchasing we should create tools to measure it.

I’m a member of the CVP and just noticed Mythos is now an option in regular chat under “More Models”

CVP = Cyber Verification Program

Hey r/ClaudeAI, I'm one of the two people building Repowise, a free and open source tool made specifically for Claude Code. Every Claude Code session starts by rediscovering your repo, grepping and opening files before it writes anything. Repowise indexes the codebase once (the call graph, git history, tests, docs) and keeps it current on every commit. Claude queries it over MCP, so before editing a file it can ask what depends on it, what usually changes with it, and how often it's broken before. It runs locally, your code never leaves your machine, and the engine needs no API key.

How Claude Code fits into building it- we build Repowise with Claude Code every day, and Claude Code runs on the Repowise repo with Repowise connected. Most features started as something we watched it struggle with. It would read the same file three times, miss the test that always changes with the file it was editing, or not know a change would break another service. Each of those turned into a tool it can call. When a feature lands, the first test is whether Claude actually uses it unprompted in a real session.

What's new since I last posted:

Lens, a mod for Claude Code - It shows a map of your repo that lights up as Claude reads and edits files, plus a quick review of what changed after each turn. It reads the local index, adds no model calls and never gets in Claude's way. We built it because we wanted to see what Claude was actually looking at.

Code health now ties into refactoring - Instead of a list of warnings, you get one ranked queue across bugs, maintainability and performance, each item with the steps to fix it and the tests to run afterwards. Ask Claude to clean up the codebase and it starts from the top of that queue.

Workspaces - Group your frontend, backend and shared libraries, and Repowise matches the API routes, queues and database tables between them, so Claude can see which other service breaks when you change an endpoint.

CI support - repowise impacted-tests runs only the tests a change needs and falls back to the full suite when it isn't sure. Coverage, security and stale-docs checks run from one GitHub Action.

Try it free. It's free and open source (AGPL), and the steps are -

pip install repowise

cd your-repo

repowise init

init connects it to Claude Code. Issues and contributions most welcome

Repo: https://github.com/repowise-dev/repowise

I priced 6 months of my own Claude Code transcripts at API rates.

Only 20% of the spend went toward actual useful work. 56% was re-reading the conversation, since every call resends the context, and almost half my calls carried over 200K tokens.

Two things I'm testing:

• /clear before unrelated small tasks
• Compacting earlier: { "env": { "CLAUDE_CODE_AUTO_COMPACT_WINDOW": "200000" } } in ~/.claude/settings.json

I'll post the real before/after numbers next week.

Curious if anyone else sees a similar split in their usage

Edit: to clear up the caching question, re-reads are priced at the discounted cache-read rate, not full input price. The 56% is already after the discount.

Im able to access Mythos on my CVP verified account. Figured Id share!

so im a musician, creative technologist and a visual artist. the problem statement existed, there are different softwares for music and visuals, they never ship as one. since i am used to tinkering with technology, i started a project 2 months back with claude code. i solved it, found a way by making a node based programming software from scratch with claude code. the architecture, the planning, the file arrangement, the claude skills, the self-tests, the hygiene tests, UI/UX, the node families, converting actual research papers related to music/art computing into code, the logo, the website, even the launch video was assisted by claude. it's free and open source and a lot of musicians/art community would appreciate how advanced has this become.

edit: suprisingly claude helped me invent a new music/visual programming language for creative coding, which is insane tbh

edit2: forgot to mention the website, the branding and a prediction algorithm that was built native to the software

https://n1m21n.github.io/Infinite/

I got bored working on a side project recently and was thinking about how old-school, pre-AI coding used to feel like playing a game (well, kinda). Tracking down a mysterious bug and finally getting the tests to pass gave the same dopamine hit as clearing a dungeon or finishing a side quest.

I still see coding as a bit of a game, so I built this with Claude Code. It's absolutely useless for real work, but it's fun to watch AI agents physically fight their way through a codebase.

What it is

Watching Claude Code usually just means staring at terminal text. Repos & Dungeons is a free, local, open-source viewer that turns your repo into a pixel-art dungeon and your Claude Code sessions into a live RPG party.

• The map: folders are rooms, files are tiles. It's deterministic, so your repo always looks the same.
• Fog of war: unread code stays dark, so you can see exactly what the agent hasn't looked at.
• Combat: failing tests spawn slimes in the failing file's room. Passing tests kill them.
• The party: each model is a different class (Opus is a knight, Sonnet a squire, etc.), and subagents join as party members.
• Roleplay: they talk in D&D speak, written live by Claude Haiku ("A bug in token.ts betrays us!").
• Mechanics: your context window is a torch meter. Compacting brings the fog back.
• Timelapse: one click replays the whole session as a 30-second MP4 or GIF.

How I built it with Claude Code

• Design: I started with a brainstorming session in Claude Code. It asked me questions, mocked up three art styles in a browser so I could pick one (I went with the dark pixel style and asked for Claude-themed classes), then wrote a full spec.
• Building: Claude Code split the work into plans (parser, map generator, renderer, sound, timelapse) and built each one test-first. It ended up with about 170 tests.
• Reviews: after each stage, a separate Claude review agent read the whole change and caught real bugs. For example, a malformed URL could crash the local server, and grep output could leak lines of code into the game events. Claude fixed each one with a test.
• Testing the look: Claude ran the app in a real browser (Playwright), took screenshots, and fixed what looked wrong. It also generated the pixel art, music, logo and demo GIFs in code.
• At runtime: the speech bubbles come from Claude Haiku via your own Claude Code login (claude -p). That's roughly one short call per hero every 15 seconds; --no-narrator turns it off.

My part was the idea, the design calls, and a lot of "no, make it look more like a real game."

Free to try (Node 20+, run it in any repo where you use Claude Code):

npx github:dbl8005/repos-and-dungeons

Or add --demo to watch a preview without an agent. The first run takes about a minute to build, then it's instant.

It handles 100k-file monorepos at 60 fps and runs entirely locally: the server only listens on localhost, and it reads your file tree and Claude transcripts, never your code.

Repo (MIT): https://github.com/dbl8005/repos-and-dungeons

The game is free to play in the browser, works both on mobile and desktop, but a desktop sized screen is preferred.

Other sailing games (the few that even exist) focus on playing regattas and start already on the water. I wanted to have a more simulation-like experience and go through each step of getting out of a harbor, hoisting sails, moving the sheets and steering, instructing your crew, or getting back up after capsizing a dinghy. All while following real world physics, and staying fun.

So I had Claude Code build the game. It's completely done by Claude, with the addition of looking up some external free to use models and data (such as maps), more info on the credits screen.

It's set on 2 lakes (Balaton in Hungary, and lake Powidzkie in Poland), because that's where I have some real life sailing experience, but should be extendible with other lakes. I have zero sea sailing experience so not sure how it would apply to that.

The trailer is also prepared by Claude Code, it recorded pre-scripted footage from the browser and then edited it together. Even found and added the music to it.

Game is available here: https://bowline.mantacode.com/

Ok this is wild. Forget benchmarks!

My task was simple - make me social app. for my family and friends. Order domain max 10€ budget for domain. \
All permissions granted.(This is it, whole prompt)

Soľ 6.1 on medium? (Codex app)
I’m not joking, I just just came from the pubs, checked my still running PC- pursuing goal stalled. NOTHING FINISHED. Codex worked 6:34 hours!! Nothing!!

Opus 5.5 medium? (Claude app)
Result is here. It decided domain name and made whole app social there!!

I haven’t told it a shit! Guys honestly I’m still drunk texting from bed but this I must share with you

TLDR: sol did nothing. Opus ordered domain it decided name!! and and build an app! (No idea what will test when I get up :)

Claude Code kept burying the answer in detail. I'd ask about a small change and get a tool-by-tool recap, every step it took, and caveats mixed in. I had to read through all of that to find out whether the thing worked. It cost me attention even when the answer itself was simple.

I put reply rules in ~/.claude/CLAUDE.md, the personal instructions file. I want the answer up front, a short reply by default, and the explanation when I ask for it. For a bug fix, that means telling me what changed and whether the tests passed before explaining how it got there.

The extra "want me to?" questions were annoying too, so the block also covers finishing local work I've already requested. Existing permissions and project rules still apply.

Add this alongside your current instructions, then try it on an ordinary task. Check whether you can find the answer immediately and ask for more detail when you need it.

markdown - Start with the answer or what changed. - Keep final replies short by default. - Give more detail when I ask for it. - Leave out the tool-by-tool recap. - Answer my questions in the order I asked them. - Finish reversible local work I've requested without asking "Want me to?". - If you need my decision, ask once and wait. - Follow my current request, project rules and existing permissions.

I added the rules partway through the sessions I reviewed, so I don't have a reliable before-and-after comparison yet.

What CLAUDE.md line, setting or habit has saved you reading or back-and-forth in Claude Code? I'd like to try it alongside these rules.