u/Open-Ease685

I've this windows installation for a few years now, and besides WINDIRSTAT, I genuinely don't know how to declutter my storage without sifting through heaps of files. How has this become a standard industry practice anyway?

If anyone knows how I can clean up my storage of dead files, which, for those wondering, usually reside all over the place, but can mainly be found in the Appdata/local/* folders, please let me know. I don't want to wipe my system for the 4th time, but I might have to.

I see so many players fall to the ground from the smallest touches while watching the World Cup, and for the most part, there doesn’t seem to be any penalizations given out to them because of it? How has this become such a common tactic in football?

We'd love to hear from anyone, no matter the skill level! What's the single best tip, lesson, or insight you've learned that you think others should know?

Do gaslight me, I am sure about it

I've built the first part of the app in question — up to M39, Milestone 39, out of 165 milestones total — using a GPT-5.5 xhigh builder + GPT-5.5 xhigh reviewer loop, while the good old /goal and forget was working.

But now Codex usage limits are hitting hard. Even with 4 Plus accounts, it wasn’t enough, so I picked up an OpenCode Go account and Cursor accounts.

I was hesitant to rely on Chinese models because they weren’t that good in the past, but I started using this workflow:

• Codex GPT-5.5 xhigh as app spec writer: blueprint, milestones, and initial implementation
• DeepSeek V4 Flash as builder: almost infinite usage on OpenCode Go
• MiniMax M3 as reviewer: 3x usage on OpenCode Go, so it’s cheap to run
• Kimi 2.7 Code as second reviewer: this is expensive and burns OpenCode Go fast
• Codex GPT-5.5 medium as final reviewer: impossible to use 5.5 xhigh with Plus accounts right now

I was surprised that by the time Codex did the final review, although it still found extra issues, there usually wasn’t much left. Usually 2 back-and-forth rounds with DeepSeek V4 Flash solved most of it. So the cheaper multi-model stack seemed to get me most of the way there.

I got intrigued and asked: “How well will these models fare against GPT-5.5 on a code review task on my codebase? Which model gives me the best bang for the buck?”

So I decided to benchmark several models against the exact same review task: same codebase, same milestone, same reviewer prompt.

Result from this M58 task, sorted by severity points:

Rank	Model	Score	Severity pts	Cost	Critical	High	Medium	Low
1	Kimi 2.7 Code	88/112	94	$1.68	4	12	7	0
2	Composer 2.5 Fast	72/112	82	$0.59	4	10	5	0
3	MiniMax M3	70/112	80	$0.18	4	10	4	0
4	DeepSeek V4 Pro	68/112	80	$0.17	4	10	4	0
5	GPT-5.5 xhigh	58/112	76	$2.47	4	9	4	0
6	GPT-5.5 low	51/112	74	$0.98	4	9	3	0
7	Mimo 2.5 Pro	64/112	73	$0.18	2	11	6	1
8	Kimi 2.6	61/112	70	$0.42	3	10	3	0
9	Qwen3.7 Max	60/112	70	$2.70	3	10	3	0
10	GPT-5.5 high	46/112	68	$1.50	4	8	2	0
11	Qwen3.7 Plus	50/112	62	$0.20	3	8	3	0
12	GPT-5.5 medium	42/112	56	$1.73	4	5	2	0
13	Mimo 2.5	37/112	50	$0.02	2	7	3	0
14	DeepSeek V4 Flash	38/112	46	$0.02	1	8	3	0

The shocking part: Codex GPT-5.5 xhigh did not win. Kimi placed first, far ahead. Composer 2.5 Fast placed second, and MiniMax / DeepSeek Pro also beat 5.5 xhigh on this task.

The cost part was also surprising. GPT-5.5 xhigh cost around $2.47 for this run. Qwen3.7 Max cost even more, around $2.70. Meanwhile MiniMax M3 and DeepSeek V4 Pro both scored above GPT-5.5 xhigh on this task while costing around $0.18 and $0.17.

Caveat: this is only one milestone so far. I have up to M165 planned and will rerun this on other milestones. Also, even with the same prompt, harness/runtime differences may matter.

OBS: Severity pts means critical problems got more points than low-severity problems. That’s why GPT-5.5 xhigh found fewer total problems than Qwen 3.7 Max, but had a higher severity score.

OBS: No Claude models. I don’t feel like spending $100 only to run some benches on Claude Code. No GLM 5.1 or 5.2 either. In the past, I found that GLM 5.1 underperformed Kimi 2.6 and DS V4 Pro in code review tasks, and it’s also very expensive to run in OpenCode Go, so I left it out. GLM 5.2 is only available through API and is also expensive, so yeah, I’m not spending API prices to test it.

I published the full test results table with prompts but reddit won't let me post it here.

Update 1: Included Kimi 2.6 results

###### UPDATE 2: Adversarial review. ######

Some people reasonably pushed back that the original scoring could reward models that list more problems, even when some are false positives or irrelevant. Fair criticism.

So I asked another Codex GPT-5.5 xhigh to do an adversarial review of the reports.

This version keeps the true-positive score, but subtracts false positives and irrelevant findings. Penalties are not flat: they scale with the severity of the wrong/irrelevant claim. So a wrong “critical blocker” hurts more than a minor irrelevant nit.

Rank	Model	Findings	False positives	Irrelevant	Final	Precision
1	Composer 2.5 Fast	80	0	0	80	3.9
2	GPT-5.5 xhigh	80	0	0	80	3.8
3	Kimi 2.7 Code	78	-2	-1	75	3.4
4	MiniMax M3	78	-4	0	74	3.7
5	GPT-5.5 low	74	0	0	74	3.4
6	GPT-5.5 high	72	0	0	72	3.6
7	Qwen3.7 Max	73	-1	0	72	3.1
8	Qwen3.7 Plus	65	0	0	65	3.0
9	DeepSeek V4 Pro	64	0	0	64	3.3
10	GPT-5.5 medium	60	0	0	60	3.3
11	Mimo 2.5	60	-2	-1	57	2.2
12	Kimi 2.6	50	0	-1	49	2.6
13	DeepSeek V4 Flash	48	0	0	48	2.3
14	Mimo 2.5 Pro	50	-2	-1	47	2.5

The results show that the original scores stayed more or less consistent, but some models were more heavily penalized by the adversarial reviewer.

Final disclaimer: this is not a lab test. It does not have mathematical strength, and the reviewer/adversarial claims were not human-reviewed.

This was done on a 100k+ lines private TypeScript codebase, around one specific task: reviewing a milestone implementation. The milestone was written by GPT-5.5 xhigh, the implementation plan by Kimi 2.7 Code, and the code was built by DeepSeek V4 Flash.

One more caveat: the adversarial reviewer was a different model/run from the one that did my initial scoring. The initial scoring was done in ChatGPT, while the adversarial pass was done by Codex GPT-5.5 xhigh. So it classified some problems a bit differently, which adds some variance to the adversarial results.

There are a lot of tips on how to create a web-to-corpus pipeline that make it sound like the difficult part of the process is selecting the right “crawler,” “dedup” method, or “ranking heuristic.”

I believe the real issue is that each “cleanup” step can subtly corrupt the dataset.

Exact-hash dedup is safe, but it fails to detect most real web duplication. MinHash can detect pages that are copied or lightly edited, but if tuned too aggressively, it can flatten pages like changelogs, API docs, short forum answers, or code-heavy pages. Clustering sounds smarter, but it can obscure what matters in technical text, such as differences in versions, negations, edge cases, and implementation notes.

It is similar to curriculum design. “Easy to hard” is a nice thing to say until you realize that your difficulty signal is probably based on document length, readability, or how clean the HTML was. At that point, you are not developing a curriculum. You are simply sorting by artifacts.

This is the same trade-off as crawler choice. Async HTTP is great for static pages. When the product of crawling is structure, Scrapy gives you that. Playwright should be a last resort, not the norm, because it kills throughput like a brick wall.

Store raw fetches. Version extraction and normalization. Dedup in stages. Preserve provenance, robots, license, and policy metadata. Write shards using manifests. Make sure you can justify why a document was included six months later.

A lot of structural analysis reviews treat FEA/test correlation like a pass/fail check:

Simulation close to test result = model validated.

But sometimes the model matches because it’s wrong in two ways that cancel each other out.

Examples:

• Boundary conditions too stiff, but material modulus too low
• Bonded contact too stiff, but fixture compliance missing
• Missing bolt preload offset by friction set too high
• Coarse mesh hiding stress peaks while over-constrained supports inflate stress elsewhere

Each can make one metric look “right.” Peak displacement matches. Max stress looks reasonable. The contour plot looks convincing.

But the load path can still be wrong.

That’s the dangerous part. The model may match the first test, then fail on the next design change because it never captured the real physics.

A better check is to perturb assumptions one at a time: fixture stiffness, friction range, contact behavior, preload, mesh density. If several different assumption sets can all be tuned to match the same test number, that number didn’t really validate the model.

Good correlation should be pattern-based, not just scalar-based. It’s much harder to fake displacement, strain distribution, reaction forces, failure location, and deformation shape all at once.

The better question is not “does the number match?”

It’s “which assumption is driving the mismatch?”

Matching one test result should be the start of validation, not the end.

The shift is real, but the usual “e-commerce killed stores” framing is too simple.

U.S. e-commerce went from 0.6% of retail sales in Q4 1999 to 11.2% in Q4 2019, then 16.4% by Q3 2025.

That’s a big move, but it wasn’t smooth.

Before COVID, online retail was already gaining share steadily, especially through the 2010s. It had stopped being a niche and had become a normal growth channel.

Then COVID messed up the chart.

In Q2 2020, e-commerce share jumped from 11.9% to 16.3% in one quarter. That wasn’t some clean adoption curve. A lot of people were buying online because they had no better option.

Then some of it reversed. By 2022, e-commerce share was back around 14.2%.

So I don’t think the pandemic “changed everything forever.” But it also didn’t change nothing. It pulled some adoption forward, then gave part of it back.

Since 2023, the share has been climbing again, just more slowly. It went from 15.0% in Q1 2023 to 16.4% in Q3 2025.

So the story is probably:

• online is still gaining share
• the pandemic spike was not fully permanent
• the post-pandemic pullback was not a reversal
• the current trend is slower, but still positive

For retailers, that matters. Treating 2020 as the new normal would have been a mistake. Treating the 2021–2022 pullback as proof that e-commerce stalled would also be a mistake.

The more realistic version is boring but useful: e-commerce has been taking share for 25 years, got a temporary COVID boost, gave some of it back, and is now back to grinding upward.

If you’re like me, and linking a 12 month order sheet to a delivery sheet by supplier and material thickness, the main trade-off is speed vs durability. A workbook can look fine early on, then fall apart once new months get added or source data gets messy.

How the formulas compare

SUMIFS is usually best for numeric outputs like delivered quantity, open quantity, or totals by supplier and thickness. It handles multiple criteria cleanly and is usually the most reliable.

XLOOKUP is better for returning one field, like status or promised date. It works for multi-key joins, but only if the match is truly unique.

INDEX/MATCH still works, but it is harder to audit and usually not the best choice unless you need compatibility with older Excel versions.

Why lookups fail or return wrong values

The common issues are:

• extra spaces or inconsistent supplier names
• thickness stored as text in one sheet and number in another
• duplicate supplier and thickness combinations
• fixed ranges that do not expand with new data

The bigger risk is often not #N/A. It is a formula returning the wrong match without obvious signs.

How to structure the workbook

The cleanest setup is:

• one flat Orders table
• one flat Deliveries table
• a separate Report sheet
• Excel Tables instead of hardcoded ranges
• a helper key if needed, like Supplier + Thickness + Month

This makes it much easier to add new monthly data without breaking the report layout.

I’ve been trying to make cleaner, more readable graphs lately and realized most default tools don’t look that great out of the box.

Excel works, but it often ends up looking… basic.

Some tools look better, but take way more effort to learn.

So I’m curious what people actually use in practice:

• what you consistently go back to
• what gives you good results without too much friction
• what you’d recommend to someone who cares about how charts actually look
• Bonus if you’ve switched tools and noticed a big difference.

They said they would cut the 2x usage bonus and cut more of the 5 hours limits, but the consumption has raised to 10x, 15x of what it was before. Codex has become useless for Plus users, two simples prompts now use 75% of the 5h limit. No point of paying anymore, probably switching to Claude soon.