Choueb Mahamat Issa

Founder @dabantiai

[a16z @a16z]

Wiz co-founder and CTO Ami Luttwak says AI can now carry out cyberattacks in 20 minutes that once took skilled attackers weeks or months.

In his view, companies need to continuously attack their own systems with the latest AI models to stay secure. For startups, that means building automated testing and patching into the development process from the beginning.

Ami joins a16z's Sarah Wang and Zane Lackey to discuss what changed during Black October, why patching is falling behind, the cost of continuous security testing, and why better security architecture matters more than simply buying more tools.

0:00 Intro
1:04 Welcome to Black October
3:19 How AI made every day a zero day
6:51 The PHP vulnerability: 70% of the internet
9:19 Why patching can't keep up
11:32 How Wiz uses AI to find vulnerabilities
16:59 The cost of continuous testing
19:23 Cloud security in the AI era
22:18 The red agent: attack yourself first
26:41 Agent swarms attacking your own systems
28:43 What founders must do before they ship
32:15 Where security budgets should go
36:10 Most of what security teams do isn't security
43:34 Scan for Good and public infrastructure

YouTube: https://t.co/vNBMPZlmji

@amiluttwak @sarahdingwang @zanelackey

[Anurag Jha @anuragdotdev]

SOFTWARE ENGINEERING ROADMAP
│
├── 1. Programming Fundamentals
│ ├── Programming Concepts
│ │ ├── Variables & Data Types
│ │ ├── Operators & Expressions
│ │ ├── Conditionals & Loops
│ │ ├── Functions & Recursion
│ │ ├── Scope & Closures
│ │ ├── Error & Exception Handling
│ │ ├── Memory Management
│ │ └── Debugging Techniques
│ ├── Programming Languages
│ │ ├── C / C++ Fundamentals
│ │ ├── Java
│ │ ├── JavaScript
│ │ ├── TypeScript
│ │ └── Python
│ ├── Object-Oriented Programming
│ │ ├── Classes & Objects
│ │ ├── Encapsulation
│ │ ├── Inheritance
│ │ ├── Polymorphism
│ │ ├── Abstraction
│ │ └── Composition
│ ├── Functional Programming
│ ├── Data Structures & Algorithms
│ ├── Git & GitHub
│ ├── Linux & Command Line
│ ├── IDEs & Developer Tools
│ └── Code Quality & Best Practices
│
├── 2. Computer Science Fundamentals
│ ├── Operating Systems
│ │ ├── Processes & Threads
│ │ ├── CPU Scheduling
│ │ ├── Context Switching
│ │ ├── Concurrency & Parallelism
│ │ ├── Deadlocks & Race Conditions
│ │ ├── Mutexes & Semaphores
│ │ ├── Virtual Memory
│ │ ├── Paging & Segmentation
│ │ ├── Memory Allocation
│ │ └── File Systems
│ ├── Database Management Systems
│ │ ├── Relational Databases
│ │ ├── Database Normalization
│ │ ├── Indexing & B-Trees
│ │ ├── Transactions & ACID
│ │ ├── Isolation Levels
│ │ ├── Query Optimization
│ │ ├── Joins & Subqueries
│ │ └── Database Internals
│ ├── Computer Networks
│ │ ├── OSI & TCP/IP Models
│ │ ├── IP & DNS
│ │ ├── TCP & UDP
│ │ ├── HTTP & HTTPS
│ │ ├── TLS & SSL
│ │ ├── WebSockets
│ │ ├── Proxies & Load Balancers
│ │ └── Network Security
│ ├── Compiler Design Basics
│ ├── Computer Architecture
│ │ ├── CPU & GPU Architecture
│ │ ├── Registers & Cache
│ │ ├── Instruction Sets
│ │ ├── Memory Hierarchy
│ │ └── Binary & Assembly Basics
│ └── Theory of Computation Basics
│
├── 3. Data Structures & Algorithms
│ ├── Complexity Analysis
│ │ ├── Big O, Omega & Theta
│ │ ├── Time Complexity
│ │ └── Space Complexity
│ ├── Arrays & Strings
│ ├── Linked Lists
│ ├── Stacks & Queues
│ ├── Hash Tables & Hash Maps
│ ├── Trees & Binary Trees
│ ├── Binary Search Trees
│ ├── Heaps & Priority Queues
│ ├── Tries
│ ├── Graphs
│ │ ├── BFS & DFS
│ │ ├── Shortest Path Algorithms
│ │ ├── Dijkstra & Bellman-Ford
│ │ └── Minimum Spanning Trees
│ ├── Sorting & Searching
│ ├── Recursion & Backtracking
│ ├── Greedy Algorithms
│ ├── Dynamic Programming
│ ├── Bit Manipulation
│ ├── Sliding Window & Two Pointers
│ └── Competitive Programming Basics
│
├── 4. Software Engineering Principles
│ ├── Software Development Life Cycle
│ ├── Requirements Engineering
│ ├── Functional & Non-Functional Requirements
│ ├── Software Architecture Fundamentals
│ ├── SOLID Principles
│ ├── DRY, KISS & YAGNI
│ ├── Design Patterns
│ │ ├── Creational Patterns
│ │ ├── Structural Patterns
│ │ └── Behavioral Patterns
│ ├── Clean Code
│ ├── Refactoring
│ ├── Technical Debt Management
│ ├── Code Reviews
│ ├── Documentation
│ ├── Agile & Scrum
│ └── Engineering Tradeoffs
│
├── 5. Frontend Engineering
│ ├── HTML5
│ │ ├── Semantic HTML
│ │ ├── Forms & Validation
│ │ ├── Accessibility
│ │ └── SEO Fundamentals
│ ├── CSS3
│ │ ├── Box Model
│ │ ├── Flexbox & Grid
│ │ ├── Responsive Design
│ │ ├── Animations & Transitions
│ │ └── CSS Architecture
│ ├── JavaScript
│ │ ├── Execution Context
│ │ ├── Event Loop
│ │ ├── Promises & Async/Await
│ │ ├── Closures & Prototypes
│ │ ├── DOM Manipulation
│ │ ├── Event Delegation
│ │ └── Browser APIs
│ ├── TypeScript
│ │ ├── Types & Interfaces
│ │ ├── Generics
│ │ ├── Utility Types
│ │ ├── Type Narrowing
│ │ └── Advanced Types
│ ├── React
│ │ ├── Components & Props
│ │ ├── State Management
│ │ ├── Hooks
│ │ ├── Context API
│ │ ├── Component Lifecycle
│ │ ├── React Server Components
│ │ ├── Performance Optimization
│ │ └── Error Boundaries
│ ├── Next.js
│ │ ├── App Router
│ │ ├── Server & Client Components
│ │ ├── Server Actions
│ │ ├── SSR, SSG & ISR
│ │ ├── Routing & Middleware
│ │ └── Caching & Revalidation
│ ├── State Management
│ │ ├── Redux Toolkit
│ │ ├── Zustand
│ │ └── TanStack Query
│ ├── Styling
│ │ ├── Tailwind CSS
│ │ ├── CSS Modules
│ │ └── Component Libraries
│ ├── Frontend Testing
│ │ ├── Jest / Vitest
│ │ ├── React Testing Library
│ │ └── Playwright / Cypress
│ └── Web Performance & Core Web Vitals
│
├── 6. Backend Engineering
│ ├── Backend Fundamentals
│ │ ├── Client-Server Architecture
│ │ ├── Request-Response Lifecycle
│ │ ├── REST API Design
│ │ ├── API Versioning
│ │ ├── Middleware
│ │ └── Error Handling
│ ├── Backend Languages & Runtimes
│ │ ├── Node.js
│ │ ├── Java & JVM
│ │ ├── Go
│ │ └── Python
│ ├── Backend Frameworks
│ │ ├── Express.js
│ │ ├── NestJS
│ │ ├── Spring Boot
│ │ ├── FastAPI
│ │ └── Gin
│ ├── API Technologies
│ │ ├── REST
│ │ ├── GraphQL
│ │ ├── gRPC
│ │ ├── WebSockets
│ │ └── Server-Sent Events
│ ├── Authentication & Authorization
│ │ ├── Sessions & Cookies
│ │ ├── JWT
│ │ ├── OAuth 2.0
│ │ ├── OpenID Connect
│ │ └── RBAC & ABAC
│ ├── Background Jobs
│ ├── Task Queues
│ ├── File & Object Storage
│ ├── Email & Notification Systems
│ ├── Logging & Error Monitoring
│ └── API Documentation
│
├── 7. Database Engineering
│ ├── SQL Databases
│ │ ├── PostgreSQL
│ │ ├── MySQL
│ │ ├── Schema Design
│ │ ├── Normalization & Denormalization
│ │ ├── Indexing Strategies
│ │ ├── Query Optimization
│ │ ├── Transactions & Locking
│ │ └── Replication
│ ├── NoSQL Databases
│ │ ├── MongoDB
│ │ ├── Redis
│ │ ├── Cassandra
│ │ └── DynamoDB
│ ├── Database Internals
│ │ ├── B-Trees & LSM Trees
│ │ ├── Write-Ahead Logging
│ │ ├── Buffer Pools
│ │ ├── MVCC
│ │ └── Query Execution
│ ├── ORMs & Query Builders
│ │ ├── Prisma
│ │ ├── Drizzle
│ │ └── Hibernate
│ ├── Caching Strategies
│ ├── Database Replication
│ ├── Sharding & Partitioning
│ ├── Backup & Recovery
│ └── Data Consistency
│
├── 8. Software Testing & Quality Engineering
│ ├── Testing Fundamentals
│ ├── Unit Testing
│ ├── Integration Testing
│ ├── End-to-End Testing
│ ├── Regression Testing
│ ├── Smoke & Sanity Testing
│ ├── Performance Testing
│ ├── Load & Stress Testing
│ ├── Security Testing
│ ├── Test-Driven Development
│ ├── Behavior-Driven Development
│ ├── Mocking & Stubbing
│ ├── Test Coverage
│ ├── Contract Testing
│ ├── Chaos Testing
│ └── Automated Testing Pipelines
│
├── 9. System Design Fundamentals
│ ├── Client-Server Architecture
│ ├── Monolithic Architecture
│ ├── Layered Architecture
│ ├── Modular Monoliths
│ ├── Microservices Architecture
│ ├── Service-Oriented Architecture
│ ├── Event-Driven Architecture
│ ├── Domain-Driven Design
│ ├── API Gateway
│ ├── Load Balancing
│ ├── Reverse Proxies
│ ├── Caching Layers
│ ├── Database Design
│ ├── Message Queues
│ ├── Pub/Sub Systems
│ ├── CAP Theorem
│ ├── Consistency Models
│ ├── Scalability & Availability
│ └── Fault Tolerance
│
├── 10. Distributed Systems
│ ├── Distributed Computing Fundamentals
│ ├── Network Partitions
│ ├── Replication & Sharding
│ ├── Consensus Algorithms
│ │ ├── Raft
│ │ └── Paxos Basics
│ ├── Distributed Transactions
│ ├── Two-Phase Commit
│ ├── Saga Pattern
│ ├── Eventual Consistency
│ ├── Strong Consistency
│ ├── Idempotency
│ ├── Distributed Locking
│ ├── Leader Election
│ ├── Service Discovery
│ ├── Circuit Breakers
│ ├── Retries & Backoff
│ ├── Rate Limiting
│ ├── Message Delivery Guarantees
│ ├── Kafka & RabbitMQ
│ └── Distributed System Observability
│
├── 11. Advanced System Design
│ ├── High-Level Design (HLD)
│ ├── Low-Level Design (LLD)
│ ├── Requirements & Capacity Estimation
│ ├── API & Data Model Design
│ ├── Multi-Tenant Architecture
│ ├── Multi-Region Architecture
│ ├── High Availability Design
│ ├── Disaster Recovery
│ ├── Data Partitioning Strategies
│ ├── Distributed Caching
│ ├── Search Infrastructure
│ ├── Real-Time Systems
│ ├── CDN Architecture
│ ├── Observability Architecture
│ ├── Cost Optimization
│ └── Architecture Tradeoff Analysis
│
├── 12. Microservices & Event-Driven Systems
│ ├── Service Decomposition
│ ├── Inter-Service Communication
│ ├── Synchronous vs Asynchronous
│ ├── API Gateway Patterns
│ ├── Service Mesh
│ ├── Event Sourcing
│ ├── CQRS
│ ├── Saga Orchestration
│ ├── Outbox Pattern
│ ├── Change Data Capture
│ ├── Kafka
│ ├── RabbitMQ
│ ├── NATS
│ └── Service Reliability
│
├── 13. Security Engineering
│ ├── OWASP Top 10
│ ├── SQL Injection
│ ├── XSS & CSRF
│ ├── SSRF
│ ├── Authentication Security
│ ├── Authorization & Access Control
│ ├── Password Hashing
│ ├── Encryption & Hashing
│ ├── TLS & Certificate Management
│ ├── Secrets Management
│ ├── API Security
│ ├── Secure Coding Practices
│ ├── Dependency Vulnerabilities
│ ├── Supply Chain Security
│ ├── Threat Modeling
│ └── Security Auditing
│
├── 14. Cloud Computing & Infrastructure
│ ├── Cloud Fundamentals
│ ├── AWS
│ │ ├── IAM
│ │ ├── EC2
│ │ ├── S3
│ │ ├── RDS
│ │ ├── Lambda
│ │ ├── VPC
│ │ ├── ECS & EKS
│ │ └── CloudWatch
│ ├── Google Cloud Platform
│ ├── Microsoft Azure
│ ├── Docker
│ ├── Kubernetes
│ ├── Container Orchestration
│ ├── Infrastructure as Code
│ │ ├── Terraform
│ │ └── Ansible
│ ├── Serverless Computing
│ ├── CDN & Edge Computing
│ ├── Cloud Networking
│ └── Infrastructure Cost Optimization
│
├── 15. DevOps & Platform Engineering
│ ├── CI/CD Pipelines
│ ├── GitHub Actions
│ ├── Jenkins
│ ├── Build Systems
│ ├── Containerization
│ ├── Kubernetes Operations
│ ├── Helm
│ ├── GitOps
│ ├── ArgoCD
│ ├── Infrastructure Automation
│ ├── Configuration Management
│ ├── Environment Management
│ ├── Secrets & Configuration Management
│ ├── Deployment Strategies
│ │ ├── Blue-Green Deployment
│ │ ├── Canary Deployment
│ │ └── Rolling Deployment
│ ├── Platform Engineering
│ └── Developer Experience (DevEx)
│
├── 16. Performance & Reliability Engineering
│ ├── CPU & Memory Profiling
│ ├── Application Performance Monitoring
│ ├── Database Performance Tuning
│ ├── Network Optimization
│ ├── Caching & Cache Invalidation
│ ├── Latency & Throughput
│ ├── Concurrency Optimization
│ ├── Connection Pooling
│ ├── Garbage Collection
│ ├── Horizontal & Vertical Scaling
│ ├── Load Testing
│ ├── SLI, SLO & SLA
│ ├── Error Budgets
│ ├── Incident Management
│ ├── Root Cause Analysis
│ ├── Disaster Recovery
│ └── Chaos Engineering
│
├── 17. Observability & Monitoring
│ ├── Structured Logging
│ ├── Metrics & Dashboards
│ ├── Distributed Tracing
│ ├── OpenTelemetry
│ ├── Prometheus
│ ├── Grafana
│ ├── ELK Stack
│ ├── Datadog
│ ├── Error Tracking
│ ├── Alerting Systems
│ ├── Log Aggregation
│ └── Production Debugging
│
├── 18. Software Architecture & Design
│ ├── Clean Architecture
│ ├── Hexagonal Architecture
│ ├── Onion Architecture
│ ├── Layered Architecture
│ ├── Domain-Driven Design
│ ├── SOLID in Large Systems
│ ├── Dependency Injection
│ ├── Design Patterns in Production
│ ├── Modular Design
│ ├── API Contract Design
│ ├── Backward Compatibility
│ ├── Versioning Strategies
│ ├── Legacy System Modernization
│ └── Architecture Decision Records
│
├── 19. Developer Productivity & Engineering Tools
│ ├── Git Advanced Workflows
│ ├── Monorepos
│ ├── Nx & Turborepo
│ ├── Package Managers
│ ├── Build Tools
│ ├── Code Linters & Formatters
│ ├── Static Analysis
│ ├── IDE Debugging
│ ├── API Testing Tools
│ ├── Documentation Tools
│ ├── AI-Assisted Development
│ ├── Code Generation
│ ├── Developer Environments
│ └── Technical Documentation
│
├── 20. Emerging Software Engineering Domains
│ ├── AI-Assisted Software Development
│ ├── AI Coding Agents
│ ├── Agentic Software Development
│ ├── WebAssembly
│ ├── Edge Computing
│ ├── Real-Time Applications
│ ├── Blockchain Fundamentals
│ ├── Embedded Systems Basics
│ ├── Distributed Databases
│ ├── Cloud-Native Development
│ └── Green Software Engineering
│
├── 21. Build Real-World Projects
│ ├── Full-Stack Authentication Platform
│ ├── E-Commerce Application
│ ├── Real-Time Chat Application
│ ├── URL Shortener at Scale
│ ├── Distributed Job Queue
│ ├── API Gateway
│ ├── Notification Service
│ ├── Search Engine
│ ├── Payment Processing System
│ ├── Collaborative Document Editor
│ ├── Scalable File Storage System
│ ├── Video Streaming Platform
│ ├── Distributed Rate Limiter
│ ├── Event-Driven Order Management System
│ ├── Multi-Tenant SaaS Platform
│ ├── Monitoring & Observability Platform
│ └── Production-Ready Distributed System
│
└── 22. Career Preparation
├── Build a Strong GitHub Portfolio
├── Create a Technical Resume
├── Master DSA Interviews
├── Practice OOP & LLD
├── Master OS, DBMS & Networking
├── Practice System Design Interviews
├── Learn Problem-Solving Patterns
├── Study Engineering Case Studies
├── Understand Production Architecture
├── Contribute to Open Source
├── Write Technical Articles
├── Build in Public
├── Practice Behavioral Interviews
├── Learn Engineering Communication
└── Apply for Software Engineer Roles

FINAL GOAL:
Become a Production-Ready Software Engineer

[Choueb Mahamat Issa @chouebmahamatis]

This is great! Awesome work by the team.

[Claude @claudeai]

During pre-release testing, Claude Fable 5.2 and Claude Mythos 5.2 worked on ambitious projects in many different fields. Here are a few.

From a one-paragraph prompt, Fable 5.2 designed three working electronic devices, including this home voice assistant hub.

[Dabanti @dabantiai]

We are doing some testing before releasing the Android app to Dabanti users. Surely, it will take a couple of weeks.

For the meantime, if you’re registered in our platform and want to get the most of it. We advise you to use your pc/desktop browser chromium based: edge, chrome as we’ve launched the auto Apply extension. We have extended it to Firefox users. Though, we are waiting for the review to complete so that you can use it there as well.

Back to the mobile version , it will be more intuitive to use the app than the browser. Because, this will help you avoid being spammed as bot when accessing most job platforms that we populate jobs from.

There will be some delay covering Apple users. Apple is becoming more stricter with developers with the AI rise. The first version should be more robust and pass in the first submission. Otherwise, the developer is doomed. That means we are not in hurry.

So help us by your patience and by inviting your friends and colleagues to use Dabanti for their job search. Thanks 😊

[Choueb Mahamat Issa @chouebmahamatis]

@ai_explorer25 @karpathy @rasbt @AndrewYNg @drfeifei @demishassabis @GaryMarcus @maximelabonne Can I add myself here ?

[Choueb Mahamat Issa @chouebmahamatis]

Adding this to the equation. Anthropic does only care if you have something exceptional I guess.

[Choueb Mahamat Issa @chouebmahamatis]

What is the secret behind the member of technical staff trick 😂

When I see founders joining as member. There’s something to gain after all.

In fact, being a well known company or a famous founder that has disruptive ideas can accelerate this path. Because not everyone is qualified for.

Otherwise, my mind can’t comprehend it clearly.

The same pattern we have seen with folks like Karpathy who had joined multiple times these companies.

We know that Anthropic has a lot of cash to throw at people. That might explain for general employees.

Though, if your startup is successful and generate revenue. This alone can’t explain it 🏃🏽

[Choueb Mahamat Issa @chouebmahamatis]

Just give up 😂

[Mehak @itsmeMehak_]

Day 2 of vibe coding

[Choueb Mahamat Issa @chouebmahamatis]

@Mourad_ZAIED Great work !!!

[Choueb Mahamat Issa @chouebmahamatis]

This is an interesting take!

[Mourad ZAIED @Mourad_ZAIED]

What if we could delete BatchNorm and LayerNorm entirely? 🚀 Introducing SaluNet: a framework that replaces normalization with a simple learnable geometry (just 2 scalars per layer). It works on both CNNs and ViTs. 🧵👇

[Choueb Mahamat Issa @chouebmahamatis]

Start here by registering in Dabanti

[Dabanti @dabantiai]

Auto Apply extension is available now for desktop/pc users surfing on chrome. It fills forms and requests your intervention only when required.

You’re in control of your application in the platform.

We will bring it to Firefox users, then gradually to the Apple ecosystem.