Jude Mpacko

Entrepreneur

[Jude Mpacko @judempacko]

J’ai créé un template prêt pour emploi pour build des custom thèmes WordPress avec Docker https://t.co/vL4JPJqpgT

Plus rien à installer, juste le cloner, lancer Docker et commencer à créer

[Jude Mpacko @judempacko]

@telegram Now I can’t unsee it 🫣

[Hoodie @HoodieFade_]

HOLY F*CK, can't believe my eyes, someone leaked an entire reverse engineering degree on GitHub.

This free stack completely automates dissecting closed binaries, applications, and firmware using AI agents:

1. radare2 → Full binary analysis straight in the terminal.
Replaces heavy GUI tools and lets you tear through code via scripts and CLI.
Instant execution file analysis on remote headless servers.

↳ https://t.co/HLFQkpSs8X

2. Ghidra → Free decompiler matching high-end enterprise suites.
NSA's open-source tool that completely covers commercial decompiler needs.
Visual call graphs, structured control flow, and automated logic recovery.

↳ https://t.co/LCrxavTuqy

3. LLM4Decompile → Neural machine code translation into clean C.
Specialized model that reconstructs variables and function structures after compiler passes.
Turns stripped assembly into readable source code in seconds.

↳ https://t.co/amFQlx3ujI

4. r2ai → Local AI copilot embedded in your terminal debugger.
Integrates language models directly into your active session without external chat switching.
Explains dense logic and flags cryptographic routines or bugs during live execution.

↳ https://t.co/NnyTnGfggC

5. reverse-engineering-assistant → Bridge Ghidra to AI agents via MCP.
Model Context Protocol server opening symbols, functions, and memory to external LLMs.
Lets Claude Code or Cursor explore target codebases and deobfuscate variables autonomously.

↳ https://t.co/tolqcDEXTS

6. ida-pro-mcp → Full IDA Pro orchestration without manual clicking.
Drives the industry-standard decompiler over Model Context Protocol.
Delegates xref tracing, batch symbol mapping, and binary patching directly to agents.

↳ https://t.co/aIsECl3MnF

7. REA → Autonomous software reverse engineering on autopilot.
Engine handling 35 target types: native binaries, Android APKs, Electron apps, and firmware.
Ingests a closed-source target, pinpoints target features, and generates verifiable evidence for replication.

↳ https://t.co/nE4S4GMBgp

Analysis → Disassembly → Neural Decompilation → MCP Bridge → Autonomous Report.

Bookmark this. The era of manual bytecode grinding is over ↓

[Jude Mpacko @judempacko]

🤣

[Manchester United @ManUtd]

Cole Palmer scores Chelsea's second.

[Jude Mpacko @judempacko]

@IvanPerezF_ Very bad. Someone will go to bed with anxiety these days

[Mr. Buzzoni @Mr_Buzzoni]

holy f*ck, Karpathy put an entire AI degree on GitHub for free

7 repos, 306,741 stars, and in the right order they take you from backprop to agents that run research overnight

each repo is the next layer of the one before

1. micrograd -> how a neural net actually learns
backprop in about 100 lines of Python
↳ https://t.co/sZdt2ZhTs5

2. nn-zero-to-hero -> the video course
his lecture notebooks, from one neuron to GPT
↳ https://t.co/3rINVTCeY7

3. minbpe -> how text turns into tokens
the tokenizer every LLM starts with, in clean minimal code
↳ https://t.co/eeC6ySUzES

4. nanoGPT -> your own GPT
the simplest repo to train and fine-tune one
↳ https://t.co/pw8JPMvFmf

5. llm.c -> the same training with nothing hidden
raw C and CUDA, no PyTorch underneath
↳ https://t.co/neU4gdN71w

6. nanochat -> a full chat model end to end
GPT-2 level training cost ~$43,000 in 2019
here it's about $48
↳ https://t.co/MBcyMrTtRd

7. autoresearch -> agents that do the research
an agent edits the training code, trains for 5 minutes, keeps what improved and repeats all night
↳ https://t.co/EoyCfdPydo

train one GPT from scratch and you become the person who gets handed the AI project, along with the raise that comes with it

the classroom half of the same degree, what Stanford actually teaches about AI, is below ↓

[Jude Mpacko @judempacko]

Problem solved: Opencode Go ✅

[Jude Mpacko @judempacko]

@CranelAnos @opencode Same issue here. I thought I was wondering too. I didn't touch Opencode yesterday

[Suraj Sharma @suraj_sharma14]

this is insane https://t.co/Z9XrOzu55G

[Suraj Sharma @suraj_sharma14]

Create these 6 files before you start vibe coding:

• PRD.md: what you're building and for whom
• ARCHITECTURE.md: stack, folders, data flow
• DESIGN.md: colors, fonts, components, vibe
• RULES.md: coding style and what the AI must never do
• TASKS.md: small steps, one at a time
• PROGRESS.md: what's done, what broke, what's next

No files = the AI guesses.
6 files = the AI follows your plan.

10 minutes of writing saves 10 hours of fixing.

Bookmark this before your next build.

[Jude Mpacko @judempacko]

@CranelAnos @opencode Same issue here. I thought I was wondering too. I didn't touch Opencode yesterday

[Jude Mpacko @judempacko]

@FBICyberDiv Only God knows how much I don’t like PHP. Glad I didn’t waste my time learning it

[Mashood K @fromcodetocloud]

6 engineering books you can read online for free.
If you're learning DevOps, Linux, or SRE, save these:

1. The Site Reliability Engineering Book —
Learn how Google builds and operates reliable systems.
https://t.co/4QHYhY82MN

2. The SRE Workbook —
Learn practical SRE techniques through real-world examples.
https://t.co/VlMCN8riYw

3. Pro Git —
Understand branching, rebasing, Git workflows, and internals.
https://t.co/R8xBojvPsV

4. The Linux Command Line —
Learn shell commands, scripting, and everyday Linux operations.
https://t.co/qgtrpNQo52

5. The Twelve-Factor App —
Understand how to build applications that are easier to deploy and operate.
https://t.co/yZ94YsltlD

6. The Missing Semester —
Learn shell tools, Git, debugging, and developer productivity.
https://t.co/Vt7qrHiZIf

You don't need to read all six at once.
Pick one, apply what you learn to a real project, and keep going.

[Suraj Sharma @suraj_sharma14]

If you learn Forward Deployed Engineering, you will never be unemployed again.

I’d do this.

Stage 1: Enterprise Identity & Access (The Gatekeeper)
- Learn: OAuth2, SAML, OIDC, SCIM provisioning, Row-Level Security (RLS) and multi-tenant data isolation.

- Practice: Build an auth bridge connecting your AI app to a simulated customer's Okta/Azure AD, ensuring User A can only query data their specific RBAC role permits.

- Why: No SSO and strict data isolation means no enterprise contract. Security review is the first gate.

Stage 2: Air-Gapped & VPC Deployments (The Environment)
- Learn: Kubernetes (K8s), Helm, Terraform, private container registries, air-gapped networking and egress filtering.

- Practice: Script a one-click Terraform/Helm deployment of your entire AI stack into a simulated customer VPC with zero egress to the public internet.

- Why: Banks, hospitals and governments don't let your AI talk to the public cloud. You must deploy in their basement.

Stage 3: Legacy Data Extraction & ETL (The Fuel)
- Learn: OCR, unstructured PDF parsing, mainframe DB connectors, Apache Airflow, dbt and data reconciliation.

- Practice: Build a pipeline that ingests 10 years of messy, scanned customer invoices and turns them into a clean, queryable hybrid (vector + relational) store.

- Why: Enterprise AI starves without clean data. The customer's data will always be a mess.

Stage 4: Secure RAG & Permission-Filtered Retrieval (The Brain)
- Learn: Hybrid search, document-level access control, citation grounding, metadata tagging and abstention logic.

- Practice: Build a RAG pipeline where the LLM dynamically filters out retrieved chunks that the specific user asking the question doesn't have clearance to see.

- Why: An AI that leaks HR salaries or M&A docs to a junior employee is an immediate breach of contract.

Stage 5: MCP & Legacy System Integration (The Hands)
- Learn: Model Context Protocol (MCP), SOAP/REST translation, web scraping, headless browsers and API rate-limit handling.

- Practice: Build an MCP server that lets an LLM safely query and write to the customer's 15-year-old on-prem SAP or Oracle instance without exposing raw credentials.

- Why: Agents are useless if they can't touch the customer's actual systems of record.

Stage 6: AI Guardrails & PII Redaction (The Shield)
- Learn: NER (Named Entity Recognition), deterministic regex filtering, LLM output validation, UUID masking, and audit logging.

- Practice: Build a middleware proxy that intercepts LLM inputs/outputs, masks SSNs and credit cards with UUIDs before they hit the model, and restores them post-generation.

- Why: Compliance teams will kill the deal if a single PII token hits an external frontier API.

Stage 7: Human-in-the-Loop (HITL) Workflows (The Trust)
- Learn: Temporal {dot} io, webhook routing, state machines, durable execution and UI approval gates.

- Practice: Build a workflow where the AI drafts a $50k purchase order, but physically pauses execution until a human manager clicks "Approve" in Slack or Teams.

- Why: Enterprises adopt AI only when humans remain legally accountable for the final action.

Stage 8: Edge & On-Prem Inference (The Silicon)
- Learn: vLLM, TensorRT-LLM, Ollama, GPU partitioning (MIG), and local quantized models (AWQ/GGUF).

- Practice: Deploy a quantized 8B model on a single customer-owned GPU node to handle highly sensitive triage locally without network latency.

- Why: Sometimes the data is too hot to move. You must bring the model to the data.

Stage 9: Observability & Customer Health (The Pulse)
- Learn: OpenTelemetry, Langfuse, custom Grafana dashboards, usage telemetry and cost-attribution.

- Practice: Build a "Customer Health" dashboard showing the exact cost-savings, time-saved and token-spend the AI has generated for their specific team this month.

- Why: If the customer doesn't see the ROI quantified, they will churn at renewal.

Stage 10: Evals on Customer Data (The Proof)
- Learn: Golden dataset creation, trajectory grading, shadow testing, and LLM-as-a-judge calibration.

- Practice: Take 100 real past customer support tickets, run them through your agent in shadow mode, and prove to the VP of Support that it resolved 80% accurately.

- Why: Generic benchmarks mean nothing to a buyer. You must prove the AI works on *their* messy data.

Stage 11: Technical Discovery & Scoping (The Translation)
- Learn: Stakeholder interviewing, architecture diagramming, SOW (Statement of Work) writing and expectation management.

- Practice: Translate a vague "we want AI for supply chain" executive request into a scoped, 4-week technical deployment plan with defined, measurable success metrics.

- Why: FDEs are the translators between revenue (Sales) and reality (Engineering).

Stage 12: The Handoff & Self-Serve Admin (The Scale)
- Learn: Technical writing, runbooks, admin portals, automated onboarding and chaos testing.

- Practice: Write a deployment runbook and build an admin UI so the customer's internal IT team can manage the AI stack, update prompts and view logs without calling you.

- Why: Your leverage is measured by how little the customer needs you for day-to-day operations.

AI labs build the engine. FDEs build the roads.
The modern Forward Deployed Engineer builds the secure, durable nervous system that connects frontier intelligence to legacy reality.

Bookmark and Repost!

[Anderson Nascimento @andersonc0d3]

We finally got this series out. We tried to simplify Linux kernel exploitation for those interested in getting started. There are plenty of resources out there, but my impression is that they are written for experienced people, not for beginners in this complex field.

In this series, we tried to do something close to real-world kernel exploitation, but much simpler, so people can use it as a first contact with Linux kernel exploitation. I hope people like it, and we will be available to help anyone who wants to reproduce all the content.

[Allele Security Intelligence @alleleintel]

Have you ever wanted to get started with Linux kernel exploitation? We wrote a 4-part blog series aimed at newcomers, going from setting up the environment to bypassing SMEP and KASLR. We exploit a real Linux kernel vulnerability step by step, debugging every crash along the way.

Introduction to Linux Kernel Exploitation: Vulnerability and Environment – Part 1
https://t.co/tephfqrvqD

Introduction to Linux Kernel Exploitation: Triggering the Vulnerability – Part 2
https://t.co/QEWCat60VA

Introduction to Linux Kernel Exploitation: Exploitation – Part 3
https://t.co/qqL6IPAUk3

Introduction to Linux Kernel Exploitation: Mitigation Bypass (KASLR and SMEP) – Part 4
https://t.co/O3bgNpU5wI

[Jude Mpacko @judempacko]

@gabbytech01 If I were that CISO, this post would be an instant rejection.
Posting private recruiter chats and interview details in real-time is a massive red flag. No CISO will hire someone who is an active risk for data leaks. Delete this before they see it.

[Jude Mpacko @judempacko]

Chelsea fans (me included) after this Man City loss

[Domino's Pizza UK @Dominos_UK]

Man City 0 PSG 114

[Google Cloud Tech @GoogleCloudTech]

To mark the 10th anniversary of the Google SRE book, we are excited to announce a completely rewritten second edition that reflects a decade of lessons and offers fresh guidance for today's operational challenges.

Check it out → https://t.co/QbdqnWuVcj

[Jude Mpacko @judempacko]

@suraj_sharma14 Builder

[Suraj Sharma @suraj_sharma14]

As a Backend Engineer in the AI era, you must build these projects.

1.) High-Concurrency HTTP Server
Build: Go or Rust server handling 10k+ concurrent connections with graceful shutdown and backpressure.

Why: Concurrency architecture is the one thing AI cannot design for you.

2.) Multi-Tenant Hybrid Search Database
Build: Postgres with Row-Level Security + pgvector + BM25 hybrid ranking across isolated tenants.

Why: Structured data and semantic embeddings now share one query engine.

3.) Event-Sourced Order Pipeline
Build: Kafka or NATS pipeline with immutable events, dead-letter queues, exactly-once semantics.

Why: AI workloads are slow and async. The main thread must never block.

4.) Durable Onboarding Workflow
Build: 3-day Temporal workflow with checkpoints, retries and human approval steps.

Why: Background jobs are for emails. Durable execution is for multi-step agents.

5.) AI Gateway with Semantic Cache
Build: Proxy that caches similar prompts via embeddings, enforces token budgets and fails over to a cheaper model on 503s.

Why: The gateway protects your margins and your uptime from flaky, expensive LLM APIs.

6.) PII-Redacting Auth Middleware
Build: OAuth2/OIDC provider plus middleware that masks PII before logging and restricts AI agents to read-only DB roles.

Why: When agents can write to your database, a prompt injection is a data breach.

7.) Real-Time Streaming Dashboard
Build: SSE/WebSocket dashboard streaming LLM tokens and database updates simultaneously with backpressure.

Why: Time-To-First-Token and perceived latency are the new UX standards.

8.) Correlated Tracing Pipeline
Build: OpenTelemetry + Langfuse pipeline linking each HTTP request to the exact LLM prompt and DB query it triggered.

Why: You cannot debug a hallucination without replaying the exact context the model saw.

9.) Ephemeral Environment Provisioner
Build: Terraform or Pulumi scripts spinning up a complete isolated staging environment for every pull request.

Why: Manual deployments are a liability. Infrastructure must be version-controlled and reproducible.

10.) Queue-Based Autoscaler
Build: KEDA autoscaler spinning nodes up on Kafka queue depth and down when empty with spot-instance fallback.

Why: Backend engineers now own the cloud bill. Idle resources burn runway.

11.) Globally Distributed Rate Limiter
Build: Redis-backed distributed rate limiter that survives network partitions gracefully.

Why: Architecture must degrade gracefully not cascade into total outage.

12.) Chaos Engineering Suite
Build: Fault-injection harness (latency, replica kills, partitions) with SLO burn dashboards.

Why: Resiliency is proven under failure not in diagrams.

13.) Webhook Reconciliation Engine
Build: Idempotent event processor with exponential backoff, dead-letter queues and replay tooling.

Why: Real integrations fail constantly. Reconciliation is what makes them trustworthy.

14.) Cost-per-Request FinOps Dashboard
Build: Per-tenant, per-endpoint, per-LLM-call cost rollups with anomaly alerts.

Why: Visibility is control. You cannot optimize what you cannot attribute.

15.) Public Architecture Teardown
Build: 3 published deep-dives with system diagrams, ADRs and latency/cost benchmarks.

Why: Senior engineers are hired for their judgment not their syntax.

Systems that prove you can scale, secure & ship when agents touch your stack.

Most people watch tutorials. Builders ship systems.

Bookmark & Repost.