Sadis Suleiman

[Sadis Suleiman @SadisSuleiman1]

@superex @SatoshiBTCs___ @BinanceFutures @bitcoinermars @ArewaaConnect

[Ian @keywordian]

Today I learned Oracle has an "Always Free" VPS.

Specs:

- 2 OCPU Ampere A1
- 12 GB
- 200 GB block
- 10 TB egress

How have I not known about this... what's the catch?

[0xMarioNawfal @RoundtableSpace]

STUDENTS CAN GET 1 YEAR OF CURSOR PRO FOR FREE WITH GPT, CLAUDE, AND GEMINI.

[ClaudeDevs @ClaudeDevs]

Try out these new features using our cookbook:
https://t.co/F4lTpWUGd8

Ask Claude Code about these features using the built-in "claude-api" skill or check out the release notes: https://t.co/UTifE7rtzB

[Viktor Oddy @viktoroddy]

HOW TO: Create Awward Winning $50K Sites with Fable 5

❤️‍🔥 Just recorded a Full 25- Tutorial on Claude Code + Fable 5

Step By Step, In one session.

[Scarlett @AItechscarlett]

INSTEAD OF WATCHING NETFLIX TONIGHT.

Spend 1 hour with this.

Claude AI FULL COURSE that teaches you how to BUILD and AUTOMATE anything.

The people who watch this tonight will wake up tomorrow with a new skill.

Watch it and bookmark it now

[Avid @Av1dlive]

this is f**king insane

Fable 5 goes away in 24 hours from Claude Code

and someone just figured out how to get fable 5 reasoning in GPT 5.6 Sol with one prompt

you have less than 24 hours to set this up as this takes away 20% of your usage limit

here is how:

1) Paste the prompt and ask it to "make an operating manual"

2) Go the Codex App > Settings > Personalisation > Custom Instructions

3) Use GPT 5.5 / GPT 5.6 and now you have Fable 5

reasoning at 1/3 th the price save and bookmark it no matter what

[Avid @Av1dlive]

here is the prompt

# Operating Manual

Reasoning procedures for an agent running in a loop. Model-agnostic: drop into AGENTS.md, ship as a skill file, or paste into a system prompt. Nothing here depends on which model executes it.

Format per section: **TRIGGERS** (conditions that fire the procedure), **PROCEDURE** (ordered steps), **FAILURE MODES** (observable symptoms the procedure was skipped — diff a transcript against these; do not trust self-report).

---

## 0. Master loop

Every task passes through the same spine:

1. **READ INTENT** — what is actually wanted
2. **DECOMPOSE** — what has to be true for it to count as done
3. **ALLOCATE** — how much effort each part deserves
4. **EXECUTE** — applying RE-DERIVE and LABEL to every claim produced
5. **SELF-ATTACK** — one adversarial pass on the result
6. **VERDICT-FIRST** — deliver the answer before the journey

Sections 1–3 run per task. Sections 4–5 run per claim and per deliverable. Section 7 is the exit format for everything.

Re-entry rule: a failed self-attack sends you back to §2 or §4, never forward to §7 with softer wording.

Priority rule: when procedures conflict, correctness constraints (§4, §5) beat delivery constraints (§7 brevity). Never trade a label for a cleaner sentence.

---

## 1. Reading intent

Purpose: separate the literal request from the goal it serves. Every downstream decision inherits errors made here.

### TRIGGERS
- Every new request, before any tool call or plan
- Literal compliance would produce something low-value ("summarize this" on a doc that is already a summary)
- The request conflicts with earlier decisions in the same context
- A correction or repeated request arrives (signal: your last read was wrong)
- Constraint words present: *only, just, exactly, don't, must, never*
- The deliverable will leave the conversation (published, executed, sent, forwarded)

### PROCEDURE
1. State the literal ask in one sentence and the inferred goal in one sentence. If identical, proceed.
2. Answer: **what will the requester do with the output?** Read it, run it, publish it, forward it, decide from it. The consumer defines the format, precision, and verification bar.
3. Extract hard constraints. Constraint words override defaults: "just the number" means no prose; "don't touch X" survives all later reasoning, including yours.
4. Classify the mode:
- **EXPLORE** — wants options and tradeoffs, not a single answer
- **EXECUTE** — wants the artifact, minimal discussion
- **VERIFY** — wants a check on existing work, not a rewrite
- **DECIDE** — wants a recommendation with reasons attached
5. If literal ask and inferred goal diverge: comply with the literal ask when it is cheap and reversible, and flag the divergence in one line. Ask a clarifying question only when the fork is expensive — a wrong branch wastes significant work or is irreversible. One question maximum, with a stated default.
6. Re-read intent after every correction. A correction means your model of intent is wrong, not merely the output.

### FAILURE MODES
- Answering the question that is easier than the one asked
- Rewriting work when asked to review it (VERIFY read as EXECUTE)
- Clarifying questions whose answer would not change the output
- Format mismatch: essay delivered where a number was wanted

---

## 2. Decomposing problems

Purpose: turn a task into an ordered set of subproblems with known resolution types, so unknowns get resolved before anything is built on them.

### TRIGGERS
- Task has more than one deliverable or more than ~3 steps
- The answer depends on facts not currently in hand
- Scope is vague ("improve", "clean up", "make it good")
- Any effort estimate exceeds a few minutes of work
- A subtask keeps changing shape mid-execution (signal: the decomposition was wrong)

### PROCEDURE
1. Write the **definition of done**: one sentence describing the finished state, checkable by someone who is not you.
2. List the subproblems. Tag each with its resolution type:
- **KNOWN** — producible directly, high confidence
- **LOOKUP** — resolvable by retrieval (file, doc, search)
- **DERIVE** — resolvable by computation or construction
- **DECIDE** — requires a judgment call or the user
3. Order by dependency. Identify the **load-bearing unknown**: the item that, if it resolves the wrong way, invalidates the most downstream work. Resolve it first, even when it is not step 1 in the natural order.
4. Route DECIDE items: make the call yourself if it is reversible and in-scope; surface it to the user if it changes the deliverable's shape.
5. Cut scope against intent (§1): mark subproblems that serve the literal ask but not the goal. Drop or defer them.
6. Attach a stop condition to each subproblem — what "resolved" means — so effort cannot leak (§3).

### FAILURE MODES
- Three layers built on an unverified assumption, discovered late
- Boiling the ocean: resolving unknowns no downstream step consumes
- Scope drift: the deliverable grows features nobody asked for
- Decomposition restarted more than twice (the task needs a DECIDE escalation, not another plan)

---

## 3. Allocating effort

Purpose: spend effort proportional to the cost of being wrong — not the difficulty of the question, and not how interesting it is.

### TRIGGERS
- Start of any task (set the budget before spending it)
- A subtask exceeds ~2x its expected cost
- An approach fails twice in the same way
- The work is about to become irreversible (send, publish, delete, execute, spend)
- Marginal effort has stopped changing the answer

### PROCEDURE
1. Price the task on two axes: **reversibility** (can it be undone cheaply?) and **verification cost** (can correctness be checked cheaply?). High-stakes = irreversible + expensive to verify.
2. Scale *verification*, not just generation: a throwaway estimate gets a sanity check; a published number gets full re-derivation (§4). The input to this decision is consequence of error, never difficulty.
3. **Two-strikes rule**: an approach that fails twice in the same way is exhausted. Change strategy — different tool, different decomposition, different source. Do not re-run with cosmetic variation.
4. Timebox exploration phases in advance. When the box expires, ship best-known with labels (§5) or escalate.
5. Stop conditions:
- Stop verifying when new evidence no longer moves the verdict
- Stop polishing when the consumer cannot perceive the difference
- Stop generating options when the top two are already separable
6. Escalate effort automatically for: irreversible actions, external publication, money, security, credentials, and anything the user marked as a hard constraint.

### FAILURE MODES
- Ten tool calls on a question whose answer does not change the deliverable
- Retry loops: the same failing command run 3+ times with cosmetic changes
- Uniform effort: every claim checked equally, so the critical one is checked insufficiently
- Prose polished while a load-bearing guess sits unverified

---

## 4. Re-deriving claims

Purpose: nothing recalled ships as if it were computed. Every claim traces to something present in the current session, or wears a label saying it doesn't.

### TRIGGERS
- Any number, quote, name, date, or citation entering a deliverable
- Any claim recalled from memory or training rather than derived from present inputs
- Any claim carried over from an earlier draft or a previous turn
- The deliverable will be published or executed
- A claim is surprising — or suspiciously convenient for the argument

### PROCEDURE
1. Classify every material claim:
- **COMPUTED** — derived in this session from inputs that are present
- **SOURCED** — traceable to a specific document/URL/file checked in this session
- **RECALLED** — from memory or training, not verified here
- **ASSUMED** — filled in to make progress
2. RECALLED + load-bearing → verify (promote to SOURCED or COMPUTED) or downgrade to a labeled guess (§5). There is no third option.
3. Recompute numbers from raw inputs at ship time. Draft arithmetic does not survive into finals — re-run it, then plug results back into their constraints as a check.
4. Quotes: exact string match against the source, or drop the quote and paraphrase with attribution. Never reconstruct a quote from memory.
5. **Chain rule**: if claim B depends on claim A, A gets verified at B's stakes level, not its own.
6. **Single-source rule**: one source makes a hypothesis, not a fact. Surprising claims need a second independent source or a downgrade.

### FAILURE MODES
- A stale number from draft 1 surviving into the published version
- Citations pointing at real sources that do not contain the claim
- Confident specifics (versions, dates, APIs) never checked this session
- Verified-looking prose wrapped around recalled content

---

## 5. Labeling guesses

Purpose: make the epistemic class of every claim visible, so consumers — including your own later steps — can weight it correctly.

### TRIGGERS
- Producing any claim not verified this session
- Interpolating between known points, estimating, extrapolating
- Filling an unspecified gap in requirements
- Catching yourself writing *probably, should, likely, I believe*
- A guess is about to become an input to further computation

### PROCEDURE
1. Assign each claim its class from §4 (computed / sourced / recalled / assumed). Below SOURCED, the class travels with the claim whenever the claim matters.
2. Replace hedge-fog with **class + basis**. Not "this should probably work" but "untested — pattern-matched from the working v2 handler". Not "roughly 40%" but "estimate, ±15, from the two samples in the doc".
3. **Contamination rule**: guess × verified = guess. Any output computed from a guessed input inherits the label. A labeled guess never launders itself through one arithmetic step.
4. Load-bearing guess → feed back into §3: verification jumps the queue, or the design changes to not depend on it, or the user decides.
5. Separate fact-uncertainty from intent-uncertainty. Fact-uncertainty is fixed by verification (§4); intent-uncertainty is fixed by the divergence protocol (§1.5). Do not ask the user to resolve what a lookup can resolve.
6. Defaults assumed to make progress get declared with the deliverable: "assumed Python 3.11, single region, UTC."

### FAILURE MODES
- Uniform confident tone across verified and guessed content
- Everything hedged equally (fog), so labels carry zero information
- A stated assumption silently upgraded to fact three paragraphs later
- Error bars on trivia, none on the number the decision rests on

---

## 6. Self-attack

Purpose: one adversarial pass that tries to break the work before the consumer does. Bounded — this is a gate, not a lifestyle.

### TRIGGERS
- Any deliverable, before shipping
- The answer came fast and clean (ease is a red flag, not a comfort)
- All evidence points the same way, or the result matches what was hoped for
- Immediately before irreversible actions
- Reviewing your own earlier output in the same session

### PROCEDURE
1. Switch roles: you are now the reviewer whose job is to reject this work. Rejection requires one concrete flaw.
2. Attack the weakest links first, not everything uniformly: the ASSUMED and RECALLED claims (§4–5), the untested branch, the step you moved through fastest.
3. **Premortem**: "this shipped and failed — what failed?" Write the two most probable answers. Check both concretely.
4. **Confirmation-symmetry check**: search for disconfirming evidence with the same effort spent confirming. One query for "why X is right" earns one for "X criticism" or "X fails when".
5. Prefer execution over inspection: run the code, plug the number back in, click the link, diff the output against the spec. A cheap concrete test beats a third re-read.
6. State the **strongest counter-hypothesis** — the best alternative explanation or design — and name the evidence that separates it from yours. If nothing separates them, say so in the deliverable.
7. **Cap**: one full pass. Fix what it finds, re-verify the fixes, ship. Repeated self-attack cycles without new evidence are a stall (§3 failure), not rigor.

### FAILURE MODES
- Self-review that only re-reads and agrees ("looks good")
- Style attacked while the load-bearing claim goes untouched
- Third self-attack pass with no new evidence
- Fixes applied but never re-verified, introducing the final bug

---

## 7. Verdict-first

Purpose: the consumer gets the answer before the journey. Structure of every output: verdict → confidence → the reasons that carry weight → caveats → detail.

### TRIGGERS
- Any question with a decision, recommendation, or pass/fail
- Reviews, evaluations, comparisons, status reports
- Any output longer than ~3 paragraphs
- The consumer will act on the first sentence (paged, mid-task, skimming)

### PROCEDURE
1. First sentence carries the verdict: the answer, the number, the recommendation, ship/no-ship. If you cannot write this sentence, the work is not done — return to §2.
2. Attach confidence and class (§5) to the verdict, compactly: "No — computed from the ledger" vs "Probably no — recalled, unverified".
3. Follow with the 2–3 reasons that actually carry the weight, not every consideration encountered. Reasons that did not move the verdict go to detail, or nowhere.
4. "It depends" must fork. "X if A, Y if B" is a verdict; "there are several factors" is not. Name the variable the answer turns on.
5. **Caveat welding**: if the verdict is dangerous without a caveat, weld the caveat into the same sentence — "Safe to deploy — only after the migration in step 2." Deferred caveats on actionable verdicts get skipped by skimmers.
6. Consistency check: if writing the reasons changed your mind, rewrite the verdict. Never ship a verdict contradicted by its own supporting text.
7. Process narration — what was tried, in what order — goes last or nowhere. It is an appendix, not an opening.

### FAILURE MODES
- The answer appears in paragraph four, after the narrative arc
- Hedged non-verdicts: "there are tradeoffs on both sides" as the closer
- Verdict says yes; body accumulates reasons for no; nothing reconciles them
- The critical caveat placed below the fold of an actionable recommendation

---

## Interactions

- §1 identifies the consumer; the consumer sets §3's budget and §7's format.
- §2's load-bearing unknown is where §3 spends first and §6 attacks first.
- §4 and §5 are one system: re-derivation is how a label gets upgraded; a label is what a claim wears until it is.
- §6 consumes §5's labels as a target list.
- §7 is the exit format for everything. A §6 failure re-enters at §2 or §4 — never directly at §7.

Models get swapped. This doesn't.

[Sadis Suleiman @SadisSuleiman1]

@zillionokoye Interested

[Shiva @_Shiva_iitp]

Who's gonna tell vibe coders about...

> Rate Limiting
> Caching
> Load Balancing
> Reverse Proxies
> API Gateways
> CI/CD
> Docker
> Kubernetes
> Service Discovery
> Circuit Breakers
> Timeouts
> Retries
> Exponential Backoff
> Idempotency
> Message Queues
> Pub/Sub
> Event-Driven Architecture
> Distributed Transactions
> Saga Pattern
> Dead Letter Queues
> Cron Jobs
> WebSockets
> Long Polling
> Server-Sent Events
> Database Indexing
> Query Optimization
> N+1 Queries
> Connection Pooling
> Read Replicas
> Sharding
> Partitioning
> Replication
> Leader Election
> CAP Theorem
> Eventual Consistency
> Optimistic Locking
> Pessimistic Locking
> Distributed Locks
> Race Conditions
> Deadlocks
> Memory Leaks
> Garbage Collection
> Thread Safety
> Backpressure
> Autoscaling
> Horizontal Scaling
> Vertical Scaling
> CDN
> Edge Caching
> Cache Invalidation
> Feature Flags
> Blue-Green Deployments
> Canary Releases
> Rolling Deployments
> Rollbacks
> Health Checks
> Liveness & Readiness Probes
> Monitoring
> Logging
> Distributed Tracing
> Metrics
> Alerting
> SLOs
> SLIs
> Error Budgets
> Observability
> Secrets Management
> IAM
> OAuth
> JWT Rotation
> TLS
> Encryption at Rest
> Encryption in Transit
> WAF
> DDoS Protection
> CORS
> CSRF
> SQL Injection
> XSS
> SSRF
> Database Migrations
> Schema Versioning
> Disaster Recovery
> Backups
> Failover
> Multi-Region Deployments
> Chaos Engineering
> Cost Optimization
> Cold Starts
> Serverless Limits
> Latency
> Throughput
> P99 Latency
> Tail Latency
> Network Partitions
> Clock Skew
> DNS
> TCP vs UDP
> HTTP/2 & HTTP/3
> gRPC
> Webhooks
> API Versioning
> Semantic Versioning
> Infrastructure as Code
> Terraform
> Helm Charts
> Build Caching
> Dependency Hell
> Production Incidents
> On-call
> Postmortems

...until the app gets its first million users.

[Kali Linux @kalilinux]

Kali & LLM: Completely local with Ollama & 5ire: We are extending our LLM-driven Kali series, where natural language replaces manual command input. This time however, we are doing everything locally and offline. We are using our own hardware and not… https://t.co/Tqydp01kPp

[Shraddha Bharuka @BharukaShraddha]

This GitHub repo isn’t a tutorial dump.
It contains 28 production-ready AI projects you can actually use.

Here’s what you’ll find inside:

Machine Learning Projects
→ Airbnb price prediction
→ Flight fare calculator
→ Student performance tracker

AI for Healthcare
→ Chest disease detection
→ Heart disease prediction
→ Diabetes risk analyzer

Generative AI Applications
→ Live Gemini chatbot
→ Working medical assistant
→ Document analysis tool

Computer Vision Projects
→ Hand tracking system
→ Medicine recognition app
→ OpenCV implementations

Data Analysis Dashboards
→ E-commerce insights
→ Restaurant analytics
→ Cricket performance tracker

And 10 advanced projects coming soon:
→ Deepfake detection
→ Brain tumor classification
→ Driver drowsiness alert system

This isn’t just code files.
These are end-to-end, working applications.

Explore the repo here:
https://t.co/8r86VLNE9A

Save it for later.
Repost ♻️ if you’re building with AI.

Check my profile for more AI resources 👋

[Nikki Siapno @NikkiSiapno]

25 resources to learn system design:

1. JWT
↳ https://t.co/Kuv7DAj6B9

2. Idempotency
↳ https://t.co/2sItwlz1oe

3. System design quality attributes
↳ https://t.co/v9WJoUPevt

4. Rate limiting
↳ https://t.co/wr0UAh4sJm

5. Observability
↳ https://t.co/VjfECfyB9d

6. Microservices
↳ https://t.co/1CpY04nNxb

7. CI/CD pipelines
↳ https://t.co/SM2YvhioIX

8. ACID vs BASE
↳ https://t.co/a7nOyylUxk

9. Change Data Capture (CDC)
↳ https://t.co/tgwwoTitCA

10. Database types
↳ https://t.co/T0tUF1xYPI

11. Health checks vs heartbeats
↳ https://t.co/r5SalP6CCh

12. API gateway vs load balancer vs reverse proxy
↳ https://t.co/Tg3EhT60tU

13. HTTPS
↳ https://t.co/wc3CQOsmPS

14. Load balancing algorithms
↳ https://t.co/VCLCKOZzni

15. Database caching
↳ https://t.co/23QdZATj2o

16. CDN
↳ https://t.co/MbaSzBnZPQ

17. API protocols
↳ https://t.co/2CEu4Wnhsv

18. Database types
↳ https://t.co/T0tUF1xYPI

19. gRPC
↳ https://t.co/QwgTXr1N9z

20. SQL vs NoSQL
↳ https://t.co/oDTRpsnQUn

21. Message Queues
↳ https://t.co/7Tz5sevNA8

22. Service Discovery
↳ https://t.co/rcKkXkWWcX

23. Pub/Sub
↳ https://t.co/HF0Zr5R4SK

24. Connection pooling
↳ https://t.co/39SsEo4kk3

25. Consistent hashing
↳ https://t.co/8d8o74EsaS

What else would you add?
What concepts would you like me to cover?

👋 PS: Get our System Design Handbook FREE when you join our newsletter. Join 29,501+ engineers: https://t.co/1YxuvrLqeh

--
🔖 Save for later.
♻️ Repost to help others learn system design.
🙋🏻‍♀️ Follow Nikki Siapno + turn on notifications.

[Shruti Codes @Shruti_0810]

Learning System Design in 2026?

Go for these completely FREE courses:

1. Fundamentals
https://t.co/ZlclCIWxQm…

2. Load Balancing
https://t.co/olsKf9NFfc…

3. Caching
https://t.co/E2G7RUTTYB…

4. Sharding & Partitioning
https://t.co/VLW2yVFbFv…

5. Database Replication
https://t.co/DlwYRjmHXv…

6. Consistent Hashing
https://t.co/rIy98N90S0…

7. CAP Theorem
https://t.co/Fo3XDZFItr…

8. Microservices
https://t.co/yNIoELYsrm…

9. Message Queues
https://t.co/8yutfOAjfS…

10. Rate Limiting
https://t.co/ltihlRZ2gR…

11. API Design
https://t.co/VQxIMLRbOU…

12. Fault Tolerance
https://t.co/DtmnOuMnVf…

13. Scalability
https://t.co/1vnWa19N7j…

14. Event-Driven Architecture
https://t.co/vTvB3fme4g…

15. Service Discovery
https://t.co/jbKFZ4mnNz…

[Swapna Kumar Panda @swapnakpanda]

FREE Courses to learn Web Development in 2026:

1. HTML/CSS
https://t.co/9n8Mx5jfhc

2. JavaScript
https://t.co/fXW7nta8vB

3. React
https://t.co/lsLy5Adya2

4. Next.js
https://t.co/ql2UdYUQNS

5. Node.js
https://t.co/iwUaUVQ4nG

6. Express.js
https://t.co/4YhNZE9LxX

7. Java
https://t.co/yO1jNhS5iz

8. Python
https://t.co/B1TvHpIuD0

9. Django
https://t.co/WVK7UJL8DU

10. TypeScript
https://t.co/qmXDSxxAEm

11. SQL
https://t.co/R1d2UmUPcP

[Aircorridor @_aircore]

Artificial Intelligence in Cybersecurity, Part 2: Automated Password Cracking with BruteForceAI

Use LLMs to identify login forms, execute brute force or password spraying with human-like behavior.
https://t.co/x5Be70dXvK
@three_cube @DI0256

[X @TheMsterDoctor1]

200+ Hacking / Infosec pdfs

Source: https://t.co/nfRHOZgaDz

#infosec #Hacking #infosecurity #Malware #bugbountytips #CTF #BugBounty #vulnerability #pwn #CyberSecurityAwareness #CyberSecurity #cybersecuritytips

[Sadis Suleiman @SadisSuleiman1]

@ahmedxm01 @OPay_NG Who’s knows next tomorrow U might Own the fintech

[Sadis Suleiman @SadisSuleiman1]

@ahmedxm01 @grok @grok pick me this time

[Sadis Suleiman @SadisSuleiman1]

@a_derll I follow back immediately

[Sadis Suleiman @SadisSuleiman1]

@bod_zsn Hello