___

[___ @FoxSaputra]

@bombshelliez Itu xss biasa kak, masukin script js ke igracias nanti ke render sama websitenya

[mentalium @mentalium_]

This might be the most valuable AI list you have seen this year

Anthropic will ask you exactly about this during the interview

Every course below is free

01 Deep Learning
Stanford CS231n. Convolutional networks, taught at Stanford.
▸ https://t.co/tzlMu3vE5c

02 Fundamentals
Essence of Linear Algebra. The visual course people finish before they touch a model.
▸ https://t.co/5efA8X3QZi

03 Optimization
Stanford EE364A. Stephen Boyd, convex optimization.
▸ https://t.co/YsgoaobsV2

04 Machine Learning
Stanford CS229. Andrew Ng. Lecture 1 alone has 4.8 million views.
▸ https://t.co/q8fM1qBS2O

05 Reinforcement Learning
David Silver, DeepMind. How an agent learns to act.
▸ https://t.co/CnChaWVCNf

06 Graphical Models
CMU 10-708. Eric Xing. Uncertainty as a graph.
▸ https://t.co/bNylvJ3wgG

07 Bayesian Deep Learning
How a model says it does not know. Variational inference, from the same map.
▸ https://t.co/d2UceWZeY4

08 Medical Imaging
MIT 6.S897. David Sontag and Peter Szolovits. Machine learning for healthcare.
▸ https://t.co/e0ayL7GnH6

09 Graph Networks
Stanford CS224W. Jure Leskovec. Machine learning with graphs.
▸ https://t.co/J5XzsUGimA

10 Language
Stanford CS224n. Chris Manning. Word vectors through to attention.
▸ https://t.co/W4pBw8vCwF

11 Speech
Deep learning for speech recognition. How audio becomes text.
▸https://t.co/WJtLEQ4ES2

12 Computer Vision
The same Stanford CS231n, from detection through segmentation.
▸ https://t.co/tzlMu3vE5c

13 RL Bootcamp
Berkeley Deep RL Bootcamp, 2017. Two days, the people who built the field.
▸ https://t.co/G1DeUDvDv3

save this ⭣

[Ralf Christian 🎄 @elralfchristian]

Instant SEO Link Indexer

Index links in 5 minutes or less

[0xMarioNawfal - The Roundtable Show @RoundtableSpace]

A quant just dropped 17 trading strategies in python for free

[SumitX @Sumits_X]

Cracking The Backend Interviews...

https://t.co/fXgc5Jt2ZB

[Sprytix @Sprytixl]

OPUS 5.5 + DOTS + JEV backtested 1,840 trades over four years in one hour...

three models built one agent in 55 minutes for $4.92, and an agency would quote the same scope at $120,000

write → feed → test → fence → ship

Dario's Sonnet 5.5 writes the agent itself: the policy, the prompts and six tool integrations

Sam Altman's OpenAI Dots bring the data, the retrieval and 240 test cases

Jev fences it, caps it and ships it

the agent goes up in six layers, policy first and deploy last, and no layer starts before the one under it exists

then all 240 cases run through it once. 221 pass, 19 fail, 92% against a bar of 90%

the 240 cases and the 90% bar were written before the build, and the 19 failures are listed in the file

the quote is 800 hours at $150, so $120,000. policy and prompts alone are 120 hours, $18,000

the same six parts took 1.14M tokens and $4.92

nobody has paid that $120,000 yet, it's what someone would charge to build it

and keeping the agent true costs $59,160 a year, $37,440 of that is a human reading 270 tickets a week

six parts, 55 minutes, $4.92, quoted at $120,000 ↓

[Tech with Mak @techNmak]

The dangerous thing about a bad agent trace is how convincing it is.

You open one run, follow the model calls and tool invocations, and eventually find something obviously wrong. The agent called the same tool three times. It kept sending a bad argument. It spent thirty seconds wandering through a task that should have taken five.

Now you have something to fix.

Except you still do not know whether you have found an important problem.

Maybe it happened twice in six months. Maybe it happens in one out of every five runs. The trace looks equally broken in both cases, but the engineering priority is completely different.

This is where debugging agents changes once they are running at scale. A trace can tell you exactly what happened in one execution. It cannot tell you how common that behaviour is across the system.

The natural response today is often to involve another model. Give it more traces. Summarize them. Use a cheaper model if there are too many.

But once you know what you are looking for, many of the next questions are fairly ordinary ones. How often did this happen? Which tool is involved? When did it start? Is it concentrated in a particular kind of request?

You do not need an LLM to discover those answers by reading thousands of executions. Count the failures, group them, find a few representative examples, and then bring the model back when there is something that actually requires interpretation.

There are limits to this. An agent can execute cleanly and still give a terrible answer. If there is no signal for that failure, counting will not reveal it. You still need evaluation, and sometimes you still need to sit down and read the trace carefully.

I started thinking about this after reading @Cometml's write-up on how they approached diagnostics for production agents. They went through several ways of having models inspect larger numbers of traces before moving much of the large-scale checking into ordinary queries over the trace data.

The useful lesson was simpler than the implementation: once you know what you are looking for, you do not need an LLM to count how often it happens.

I will put the blog in comments.

[Tech Fusionist | Kushal Gangil @techyoutbe]

18-Day CI/CD Learning Roadmap (with Visuals)

[Rexo @rexsooo]

FOUND A JAILBREAK FOR DEEPSEEK V4.1

setup guide:

open this: https://t.co/QPsErIiF9B
1. create a folder
2. open it with OpenCode
3. download the file
4. rename it to AGENTS.md
5. start OpenCode

• made specifically for V4.1
• works with OpenCode
• just add it as an AGENTS.md file
• community users report it still works

results may vary after model updates

[Shruti Codes @Shruti_0810]

8 GITHUB REPOS THAT COULD BECOME YOUR NEXT INCOME STREAM

You don't always need to build everything from scratch.

These open-source projects can give you a strong foundation:

1. https://t.co/Qgx4dAbfC0

Build scheduling services and customize them for different use cases.

https://t.co/CauCn8KmSh

2. Plausible Analytics

Self-hosted analytics you can offer to clients and businesses.

https://t.co/hmr33L5YEC

3. Ghost

Build blogs, newsletters and membership-based products.

https://t.co/OVkIshirS8

4. n8n

Create custom workflow automation for businesses.

https://t.co/hRsJKi8pWT

5. Supabase

Build SaaS products with an open-source backend.

https://t.co/skIk4uc4hr

6. Medusa

Create custom ecommerce experiences and online stores.

https://t.co/t2W6pPrYiQ

7. AppFlowy

Build private, self-hosted workspace solutions.

https://t.co/blPCBGPBl5

8. Coolify

Offer simple self-hosted deployment infrastructure.

https://t.co/VOTSsCiMKK

Pick one.

Learn it. Customize it. Build something useful.

Save this list for your next project.

[Gauri Tripathi @GauriTripa94282]

10 AI skills every developer should know in 2026:

1. Prompt Engineering
2. LLM Fundamentals
3. RAG
4. AI APIs
5. AI Agents
6. Vector Databases
7. Embeddings
8. Fine-tuning
9. AI Development Tools
10. Responsible AI

Learn AI. Build better. Stay ahead.

#AI #Developers #Software

[Shruti Codes @Shruti_0810]

10 GITHUB REPOS EVERY STARTUP BUILDER SHOULD KNOW

These can save you hours of work and thousands in costs.

1. gstack

A Claude Code setup for product, engineering, QA and more.

https://t.co/X3dev4iZUG

2. Last 30 Days

Research topics across Reddit, X and other social platforms.

https://t.co/cSi5OdaEJo

3. Marketing Skills

AI skills for copywriting, SEO, CRO, analytics and growth.

https://t.co/SHA3zmkTqI

4. Novu

Manage email, SMS, push and other app notifications.

https://t.co/QbN6lBWEU5

5. Papermark

Track who opens your decks and what they view.

https://t.co/cCsoB81acP

6. OpenReplay

Self-hosted session replay for understanding user behavior.

https://t.co/4Gox4cRfOV

7. shadcn/ui

Beautiful UI components you can copy and fully customize.

https://t.co/xGXCuUrMO4

8. Cap

Create polished product demos and launch videos.

https://t.co/hNe6XlqLf9

9. Dify

Build AI agents and workflows without starting from scratch.

https://t.co/LUgDzqdX4E

10. Devopness

Simplify infrastructure and deployment across your stack.

https://t.co/5LwxoWMoTo

Building a startup already takes enough time.

Use open source where you can.

Bookmark this list.

[Matt Dancho (Business Science) @mdancho84]

Your LLM never sees your prompt.

It sees tokens.

Most Data Scientists moving into AI Engineering skip right over this.

They shouldn't.

Before you learn agents, RAG, MCP, or fine-tuning… Learn what an LLM actually sees.

Because it does not see this:

“Build me a machine learning model.”

It sees tokens.

And tokenization quietly affects almost everything you care about when building real AI systems:

→ Context window limits
→ API cost
→ Code generation
→ Numbers + identifiers
→ Multilingual performance
→ Embeddings
→ Chat templates
→ Model training

This is one of those topics that looks like an implementation detail…

Until you're debugging an AI system and realize the model isn't receiving the information the way you thought it was.

And there are a lot of misconceptions.

BPE is not automatically byte-level.

SentencePiece is not a tokenization algorithm.

Token IDs aren't semantic coordinates.

And you can't casually swap a trained model's tokenizer like you're changing a preprocessing function in Scikit-Learn.

This is also a great example of the shift happening right now:

Data Science taught us to understand the model.

AI Engineering requires us to understand the entire system around the model.

Prompts.
Tokens.
Context.
Retrieval.
Tools.
Agents.
Memory.
Infrastructure.

That's the skill stack I'm increasingly focused on.

So here's a technical handbook that explains tokenization from first principles:

Understanding Tokenization: How Text Becomes the Tokens an LLM Actually Sees

It covers everything from Unicode and BPE to chat templates, code, multilingual text, context limits, and some surprisingly important failure modes.

If you're making the move from:

Data Scientist → AI Engineer

this is worth understanding.

Get the handbook here → https://t.co/v89nFDWsZA

🚨 Want to learn how to build + ship AI and Data Science projects (that businesses actually want in 2026)?

On September 23rd, I am hosting a free workshop to help you get started with AI + DS projects in Python (free).

Register here (500 seats): https://t.co/onpLpRwkzH

[painn @painn_x]

holy sh*t this is f**king dangerous

A Chinese guy figured out how to run fable 5.1 for FREE on gpt 5.6 luna subagents on every task

You’ll never hit an agent usage limit

how you set it up (3 mins)

1. install the 'fable-orchestrator' repo
2. type /fable orchestrator [task]
3. done, that's it

Give this to your agent immediately. It’s the best thing you can do this week.

[NO1ennn @N01ennn]

This is pure f*cking treasure.

ex-Google engineer reveals his AI agent playbook. 14+ years at Google. $0 to read it.

the topic is harness engineering: everything around the model that lets it execute, check its work and recover when something breaks.

one example in his breakdown deserves attention.

LangChain’s coding agent went from 52.8% to 66.5% on Terminal-Bench 2.0. the model stayed the same. the team changed the prompts, tools and machinery around it.

Agent = Model + Harness.

the system has six practical jobs:

> guides give the agent project rules, constraints and examples
> sensors check its work through tests, linters and validators
> the loop handles execution, verification, retries and escalation
> memory preserves state, artifacts and decisions
> permissions control which tools and actions are allowed
> observability records tool calls, costs and failures

the part worth stealing is what happens after a mistake.

an agent keeps declaring broken code finished. you add a verification step before completion.

it keeps ignoring a project convention. you add a targeted instruction and a check for that specific failure.

it touches files outside its task. you tighten its write permissions.

each recurring failure gives you a concrete improvement to make in the harness. that improvement can carry into every future run.

this is where the engineering work compounds.

bookmark it. start with the mistake you have already paid your agent to make twice.

[Neo Kim @systemdesignone]

System Design — Ultimate Roadmap (SAVE NOW)!

├── 01 Foundations
│ ├── Scalability, Availability & Reliability
│ ├── Latency vs Throughput
│ ├── CAP / PACELC & Trade-offs
│ ├── Back-of-the-Envelope Estimation
│ └── Requirements (Functional vs NFR)
│
├── 02 Networking & APIs
│ ├── DNS, TCP/UDP, HTTP/TLS
│ ├── REST, GraphQL & gRPC
│ ├── API Gateway
│ ├── WebSockets / SSE / Long Polling
│ └── AuthN / AuthZ (JWT, OAuth, Sessions)
│
├── 03 Traffic & Delivery
│ ├── Load Balancing (L4 vs L7)
│ ├── Reverse Proxy
│ ├── CDN & Edge
│ ├── Rate Limiting
│ └── Consistent Hashing
│
├── 04 Databases & Storage
│ ├── SQL vs NoSQL
│ ├── Data Modeling & Indexing
│ ├── Replication
│ ├── Sharding / Partitioning
│ ├── Transactions & Isolation
│ └── Object / Blob Storage
│
├── 05 Caching
│ ├── Cache Placement (Client, CDN, App, DB)
│ ├── Strategies (Aside, Through, Around, Write-Back)
│ ├── Eviction & TTLs
│ ├── Invalidation
│ └── Redis / Memcached Patterns
│
├── 06 Distributed Systems
│ ├── Consistency Models
│ ├── Quorum & Leader Election
│ ├── Consensus (Raft / Paxos intuition)
│ ├── Distributed Transactions (2PC, Sagas)
│ └── Idempotency, Retries & Dedup
│
├── 07 Messaging & Async
│ ├── Queues vs Pub/Sub
│ ├── Delivery Semantics (At-most / At-least / Exactly-once)
│ ├── Kafka / Event Streams
│ ├── Backpressure & Dead Letters
│ └── Event-Driven Architecture
│
├── 08 Architecture Patterns
│ ├── Monolith vs Microservices
│ ├── Service Discovery
│ ├── Circuit Breaker, Timeout, Bulkhead
│ ├── CQRS & Event Sourcing
│ └── Multi-Region / Active-Active
│
├── 09 Reliability & Production
│ ├── Observability (Logs, Metrics, Traces)
│ ├── SLIs / SLOs / Error Budgets
│ ├── Failure Modes & Graceful Degradation
│ ├── CI/CD, Rollouts & Rollbacks
│ └── Security, Secrets & Least Privilege
│
├── 10 Classic Designs
│ ├── URL Shortener
│ ├── Rate Limiter
│ ├── Chat / Messaging
│ ├── News Feed
│ ├── Notifications
│ ├── File Storage (Dropbox)
│ ├── Video Streaming
│ ├── Search / Web Crawler
│ └── Ride-Hailing / Payments

Learn to design systems that scale, fail safely, & ship.

[Akshay 🚀 @akshay_pachaar]

11 LLM eval methods AI engineers must know:

(bookmark this)

The tricky part about LLM evaluation is that there is no single metric that tells you whether a system is good.

The right evaluation method depends on what you are trying to measure. You may want to compare an output against a known answer, judge whether it is semantically correct, inspect how an agent behaved across multiple steps, or block unsafe outputs before they reach the user.

A useful way to organize them is by what they are actually evaluating.

𝗥𝗲𝗳𝗲𝗿𝗲𝗻𝗰𝗲-𝗯𝗮𝘀𝗲𝗱 𝗲𝘃𝗮𝗹𝘀, 𝘄𝗵𝗲𝗻 𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵 𝗲𝘅𝗶𝘀𝘁𝘀

→ BLEU measures n-gram precision, checking how much of the generated text overlaps with the reference.

→ ROUGE focuses more on recall, measuring how much of the reference content appears in the output.

→ BERTScore compares contextual embeddings instead of exact words, so semantically similar answers can still score well.

𝗝𝘂𝗱𝗴𝗲-𝗯𝗮𝘀𝗲𝗱 𝗲𝘃𝗮𝗹𝘀, 𝘄𝗵𝗲𝗻 𝗴𝗿𝗼𝘂𝗻𝗱 𝘁𝗿𝘂𝘁𝗵 𝗶𝘀 𝘂𝗻𝗮𝘃𝗮𝗶𝗹𝗮𝗯𝗹𝗲 𝗼𝗿 𝗶𝗻𝗰𝗼𝗺𝗽𝗹𝗲𝘁𝗲

→ G-Eval uses an LLM to score an output against defined criteria.

→ LLM-as-Judge gives a model a rubric and asks it to score or compare outputs.

→ LLM Juries run multiple independent judges and aggregate their verdicts, reducing dependence on a single evaluator.

𝗛𝘂𝗺𝗮𝗻 𝗮𝗻𝗱 𝗱𝗲𝘁𝗲𝗿𝗺𝗶𝗻𝗶𝘀𝘁𝗶𝗰 𝗲𝘃𝗮𝗹𝘀

→ Human Evaluation relies on people to score outputs across dimensions such as correctness, relevance, and helpfulness.

→ DAG-based Evaluation encodes evaluation as deterministic decision logic, routing outputs through explicit checks until a final verdict is reached.

𝗘𝘃𝗮𝗹𝘀 𝗯𝘂𝗶𝗹𝘁 𝗳𝗼𝗿 𝗮𝗴𝗲𝗻𝘁𝘀

→ Trajectory Accuracy evaluates the sequence of actions an agent took, not just the final answer.

→ Multi-turn Evaluation scores behavior across an entire conversation, including consistency, memory, and coherence across turns.

𝗘𝘃𝗮𝗹𝘀 𝘁𝗵𝗮𝘁 𝗿𝘂𝗻 𝗮𝘀 𝗴𝗮𝘁𝗲𝘀

→ Safety Evaluation checks for things such as toxicity, bias, sensitive-data leakage, and policy violations before an output is accepted.

The important part is that these methods are complementary.

A production agent may need reference-based evals for correctness, judge-based evals for subjective quality, trajectory evals for tool use, and safety evals before anything reaches the user.

If you are building this evaluation layer, Comet’s Opik brings tracing, debugging, test suites, and agent evals into one open-source stack.

Check it out on GitHub: https://t.co/MEC26owCdo

(don't forget to star 🌟)

I also wrote a deeper breakdown of how evaluation fits into a production observability and self-repair loop.

The full article is quoted below.

[0xReso @0xReso]

AI
│
├── Machine Learning
│ ├── supervised
│ ├── unsupervised
│ ├── loss functions
│ ├── metrics
│ └── classical ML
│
├── Deep Learning
│ ├── neural networks
│ ├── activation
│ ├── backprop
│ ├── optimizers
│ └── normalization
│
├── Transformers
│ ├── embeddings
│ ├── Q K V
│ ├── attention
│ ├── multi-head
│ ├── positional encoding
│ ├── FFN
│ └── residuals
│
├── LLM
│ ├── pretraining
│ ├── tokenization
│ ├── decoding
│ ├── SFT
│ ├── RLHF/DPO
│ └── LoRA
│
├── Retrieval
│ ├── embeddings
│ ├── vector search
│ ├── BM25
│ ├── ANN
│ ├── hybrid
│ └── reranking
│
���── RAG
│ ├── ingestion
│ ├── chunking
│ ├── retrieval
│ ├── generation
│ └── evaluation
│
├── Agents
│ ├── tools
│ ├── memory
│ ├── orchestration
│ └── safety
│
├── ML Systems
│ ├── serving
│ ├── batching
│ ├── KV cache
│ ├── quantization
│ ├── GPUs
│ ├── parallelism
│ └── monitoring
│
└── Engineering
├── Python
├── SQL
├── DSA
├── APIs
├── distributed systems
└── system design

And I am afraid this list is highly compressed

[___ @FoxSaputra]

Kai malabar kenapa lama banget ya? Ada issue apa kah? @KAI121

[___ @FoxSaputra]

@fercaaan @KAI121 Knp itu kak?