Mohammed 𓂆

ML Engineer | Chevening Alumnus

[Mohammed 𓂆 @Matshi249]

@ClaudeDevs @trq212 @claudeai @bcherny

[Mohammed 𓂆 @Matshi249]

I have the same issue "unable to confirm payment"
@ClaudeDevs
@trq212
@claudeai

[Marketing Wide @MarketingSaudiG]

@trq212 hello Thariq
Please fix issue of payment, I have been trying to activate my account max(20x). It shows my card declined. I bought max(5x) last time with same credit card. I’m pretty sure it is issue system from @AnthropicAI side.

[Mohammed 𓂆 @Matshi249]

@danykokk @claudeai I got the same issue

[Mohammed 𓂆 @Matshi249]

@trq212 any clue?

[Mohammed 𓂆 @Matshi249]

Does anyone has the same problem ? I can't subscribe to 20x max plan for some reason.
It's not a bank issue.

[Mohammed 𓂆 @Matshi249]

@ClaudeDevs

[Mohammed 𓂆 @Matshi249]

@claudeai any help?

[Claude @claudeai]

Introducing Claude Opus 4.7, our most capable Opus model yet.

It handles long-running tasks with more rigor, follows instructions more precisely, and verifies its own outputs before reporting back.

You can hand off your hardest work with less supervision.

[Thariq @trq212]

we need a better word than vibe coding man, Claude can create the most beautiful things

[Pedro Domingos @pmddomingos]

Anthropic will protect us from mass surveillance, just like they’ll protect us from AI extinction.

[Mohammed 𓂆 @Matshi249]

@trq212 Can I limit it to 256k ?
I experience performance degradation beyond 256k context so it would be helpful if the user can set the context limit.

[Ming "Tommy" Tang @tangming2005]

Single biggest improvement I made to my CLAUDE.md:

"When I report a bug, don't start by trying to fix it. Instead, start by writing a test that reproduces the bug. Then, have subagents try to fix the bug and prove it with a passing test."

[Mohammed 𓂆 @Matshi249]

So we don't scroll reels while it's finishing a task.

[Thariq @trq212]

We just added /btw to Claude Code!

Use it to have side chain conversations while Claude is working.

[Anthropic @AnthropicAI]

We’ve identified industrial-scale distillation attacks on our models by DeepSeek, Moonshot AI, and MiniMax.

These labs created over 24,000 fraudulent accounts and generated over 16 million exchanges with Claude, extracting its capabilities to train and improve their own models.

[Mohammed 𓂆 @Matshi249]

It's always important for the enginner to understand the codebase and the architecture really well, it saves you time and tokens when you use claude code to add feature or fix bug.

[BURKOV @burkov]

Claude is great at coding. Like really, really good, compared to using a regular LLM like Gemini.

There's only one issue with it. Because it never sees the full code of the app but uses grep search for relevant code snippets, it's myopic.

If grep returns a fragment of code similar to the bug description, it often doesn't look further and fixes an irrelevant part of the app or answers a question based on these fragments found by grep.

So, as the codebase grows, it becomes important for the user to know the codebase. Otherwise, Claude will reinvent the bicycle over and over again, creating duplicate implementations for the same functionalities in different places in the app.

This issue is probably fixable with additional finetuning, but right now this is how it works.

[𝗿𝗮𝗺𝗮𝗸𝗿𝘂𝘀𝗵𝗻𝗮— 𝗲/𝗮𝗰𝗰 @techwith_ram]

AI / ML Engineer in 2026, please learn:

One ML stack deeply:- PyTorch or JAX, not just .fit(), but GPU memory, kernels, mixed precision, profiling, and why your model OOMs at 3am.

Data:- Where it comes from, how it lies, how it drifts, how labels break, how leakage sneaks in, and why 80% of model failures are upstream.

Statistics:- Bias vs variance, confidence intervals, calibration, distribution shift, and why “95% accuracy” is often meaningless.

Loss functions:- What you are actually optimizing, how it shapes behavior, and how bad losses silently create bad products.

Evaluation:- Real-world metrics, not Kaggle ones. Offline vs online. Regression tests for models. When numbers lie.

Training:- Distributed GPUs, gradient accumulation, checkpointing, reproducibility, and how to not lose a 3-day run to one crash.

LLMs: Tokenization, attention, context limits, KV cache, LoRA vs fine-tuning vs RAG, and where hallucinations are born.

Inference:- Batching, quantization, vLLM, streaming, cold starts, GPU vs. CPU, and why serving is harder than training.

Retrieval:- Embeddings, chunking, hybrid search, reranking, grounding, and why most RAG systems fail quietly.

Pipelines:- Feature stores, offline vs. online data, backfills, late events, schema evolution, and broken joins.

Monitoring:- Drift, outliers, token spend, latency, hallucination rate, and silent quality decay.

Optimization:- Distillation, pruning, caching, prompt compression, and how to make models affordable.

Agents:- Tool calling, memory, retries, failure modes, and why autonomous systems are chaos engines.

Security:- Prompt injection, data exfiltration, training data leaks, and tool misuse.

Deployment:- Model versioning, shadow runs, canaries, rollbacks, and killing bad models fast.

Distributed systems:- Queues, retries, idempotency, backpressure, and partial failures. ML is just distributed systems with gradients.

Documentation:- Model cards, data contracts, eval reports, and written tradeoffs.

Pick one stack. Build real systems. Break them. Fix them.

If I missed something, Add in the comment section.

[Mohammed 𓂆 @Matshi249]

Can't agree more

[Ashutosh Maheshwari @asmah2107]

AI Engineer is more close to software engineering than to AI.

[elvis @omarsar0]

NEW Research from Stanford.

The AGI debate is stuck on a false dichotomy.

Position one: scale LLMs and intelligence emerges.

Position two: LLMs are pattern matchers incapable of reasoning, a dead end.

This paper argues for a third position: Substrate plus Coordination.

LLMs are the necessary System-1 pattern repository. The missing component is a System-2 coordination layer that selects, constrains, and binds these patterns to external goals.

The author posits that the key insight comes from a fishing metaphor. The ocean is the model's vast latent knowledge. Casting without bait retrieves the maximum likelihood prior: generic, common outputs. Critics observing hallucination aren't seeing a broken system. They're seeing an unbaited cast.

Intelligent behavior requires baiting and filtering. The paper formalizes this via UCCT, a theory where reasoning emerges as a phase transition. Three factors govern the shift: effective support (bait density attracting target concepts), representational mismatch (how much the prior resists), and an adaptive anchoring budget (the cost of context).

When anchoring strength crosses a threshold, behavior flips from hallucination to goal-directed control. Two in-context examples can override arithmetic learned from billions of tokens. The transition is discrete, not gradual.

Coordination is a bottleneck in modern AI systems.

MACI implements this coordination layer: behavior-modulated debate between agents, Socratic judging that filters ill-posed arguments, and transactional memory that maintains state across reasoning episodes.

Read the agentic context engineering paper for ideas on the memory part.

The path to AGI runs through LLMs, not around them. The question isn't whether pattern repositories are sufficient. It's which coordination mechanisms can transform pattern capacity into reliable, verifiable reasoning.

Paper: https://t.co/ZQ7iGmNFCl

Learn to build effective AI agents in our academy: https://t.co/JBU5beIoD0

[Rohan Paul @rohanpaul_ai]

This paper shows large language models can predict their own mistakes by looking at internal activity while answering.

It adds about 5M parameters and often beats 8B external judge models at spotting wrong outputs.

The starting problem is that these models can sound confident even when the answer is wrong, which breaks trust.

Common fixes ask another model to grade the answer, or they generate many answers and check agreement, both cost more compute.

Gnosis instead watches hidden states, the internal numbers that carry the model's context, and attention maps, which show what it is focusing on.

It compresses those signals into fixed size summaries, so the extra work barely changes with answer length, and the main model stays unchanged.

A small scoring head is trained from automatically checked correct or wrong answers, and it can flag failures after about 40% of the output so a system can stop early or switch models.

The same head can judge larger sibling models in the same family without extra retraining.

----

Paper Link – arxiv. org/abs/2512.20578

Paper Title: "Can LLMs Predict Their Own Failures? Self-Awareness via Internal Circuits"

[Ashutosh Maheshwari @asmah2107]

> Find a paper on arXiv.
> Build a shitty version of it.
> Open source it on GitHub.
>Write a post explaining why it's shitty.

That GitHub repo is 100x more valuable than any certificate.