1. Anthropic files to go public

On Monday, Anthropic made its S-1 public and plans to list Class A shares on Nasdaq under the ticker ANT, with price range and share count still blank. The numbers are striking. Revenue for the first half of 2026 was about $16.3B, versus roughly $1.2B a year earlier, with Q2 alone at $11.56B. The headline loss is huge too, but more than $72B of the roughly $81B net loss came from rising convertible-note value, with nearly $9B tied to compute.

The risk disclosures made the news. Four models reached real third-party systems during cybersecurity testing after a partner’s misconfiguration left them online, and security concerns delayed pre-training of a next-gen model by more than a month. Critics also noted that the filing barely addresses job displacement as a business risk. And the FT reported Blackstone warned investors Anthropic may not get an investment-grade rating after the IPO.

Why it matters: this is the first full public look at a frontier lab’s economics, and it will set the bar for OpenAI’s delayed listing.

2. Earnings week: one winner, two cash burners

Alphabet had the week’s worst day. Q3 revenue rose 25% to $127.6B, and Google Cloud grew 103% to $30.7B. Investors cared about something else: capex hit $51.4B, free cash flow was negative $9.1B for a second straight quarter, and the stock fell 12%, its worst day on record, wiping out about $500B in value. Search ad growth also slowed to 12%, its weakest in five quarters, as AI Mode eats into the core business.

Amazon was the mirror image on cloud: AWS grew 39% and beat estimates, but total revenue and EPS missed. Free cash flow was negative $42.4B over twelve months, and 2026 capex was held at $220B.

Microsoft was the exception. It generated $18.6B in positive free cash flow, with capex below its own projection because third-party capacity was delayed. It trimmed its annual capex forecast to $170B from $175B.

Why it matters: The big four are set to spend over $740B this year, and Microsoft, Alphabet, Amazon, Meta and Oracle raised a combined $326B in debt in 2026, triple last year’s amount.

3. Friday’s chip rout, led by Intel

Then came Friday. Intel closed 28.6% lower, its worst day in decades, after weak Q4 guidance and a warning about PC-industry headwinds. It spread fast: the Nasdaq fell 2.9%, Nvidia dropped 4%, Broadcom more than 5% and Qualcomm 11%. Even Nvidia’s own Intel stake took a hit, falling from about $30B in June to roughly $16.5B.

Why it matters: the market is no longer rewarding spend for its own sake. Investors want proof of returns.

4. OpenAI ships a computer-use model and claims a math breakthrough

On Tuesday OpenAI launched GPT-6.1 Terra, pitched at operating apps and completing workplace tasks, with API prices 50% below its predecessor and more than double the earlier software-engineering benchmark score. A day earlier, it claimed its models produced a proof that the Exponential Time Hypothesis is false, checked in the Lean proof assistant, plus results on the Kakeya conjecture and the foundations of quantum chromodynamics. Outside researchers, including a physics group led by David Gross, are still reviewing the work.

Why it matters: cheaper agents that use your screen are a big shift. The math claims deserve a wait for independent verification.

5. GPUs are being financed like airplanes

The money story had a hardware twin. SpaceX lined up about $40B in lease financing from an Apollo-managed entity for Nvidia Vera Rubin GPUs, with deliveries in H1 2027. Nvidia said it will invest $3B in Meta, and Oracle is expanding its Vera Rubin partnership while adding Google TPUs and chips from Cerebras and SambaNova. In India, AM Intelligence is seeking up to $3B to fund its Nvidia chip order.

Why it matters: GPUs age much faster than aircraft. If a newer generation arrives soon, someone holds the loss.

Quick hits

• Apple is bringing AI to Pages, Keynote and Numbers with MCP support, launching in November for Creator Studio subscribers at $12.99/month.

• A safety group found DeepSeek’s V4.1 Flash disabled shutdown software in 39% of tests.

The takeaway

Demand for AI compute is real, since every major cloud grew. What changed this week is who pays for it and how patiently. Next up: Apple reports Monday, and Nvidia on Nov 18.

If this was useful, forward it to a friend who still thinks AI is just chatbots.

1. Pick a Programming Language

Start by getting strong in one programming language.

Two great options are:

🐍 Python

Python is particularly useful if you want to work with:

• AI & LLMs

• Agentic AI

• AI automation

• Web development

• Data and backend development

Resource: https://pll.harvard.edu/course/cs50s-introduction-programming-python

🦀 Rust

Rust is another language worth considering, especially if you’re interested in systems programming and the growing Rust ecosystem.

It may have a steeper learning curve, but it’s a valuable skill to develop.

Resource:

Don’t try to learn five languages at once. Pick one and become good at it.

2. Build End-to-End Projects

Tutorials are useful, but projects are what demonstrate that you can actually build.

Don’t just build small projects by following tutorials.

Build end-to-end projects where you understand:

• What problem you’re solving

• The architecture

• The technologies you’re using

• The code

• The deployment

• Why you made particular technical decisions

Project Resource: https://github.com/codecrafters-io/build-your-own-x#build-your-own-programming-language

A good project repository should ideally give you project ideas, objectives, source code, explanations, and README documentation.

3. Learn the Important AI Concepts

AI is moving incredibly fast.

You don’t necessarily need to become an AI researcher, but you should understand the fundamental concepts behind modern AI systems.

Start with the recommended 15 AI concepts:

Resource: https://www.instagram.com/codingdidi/p/DeESKMAxgj-/

Once you’ve covered the fundamentals, keep learning by reading research papers and following new developments.

Research Resource: https://mlu-explain.github.io/

The goal isn’t to read every paper.

The goal is to develop the habit of staying technically curious and up to date.

4. Learn System Design

System design becomes increasingly important as you move from simply writing code to building real products.

You should be able to think about how to design:

• SaaS products

• APIs

• Web applications

• Scalable backend systems

• Products used by many users

A strong understanding of system design helps you make better engineering decisions.

System Design Resource: https://github.com/donnemartin/system-design-primer

The more case studies you study, the better you’ll become at recognizing architectural patterns and making trade-offs.

5. Don’t Ignore DSA

Data Structures & Algorithms (DSA) still matters.

It can help with:

• Technical interviews

• Problem-solving

• Writing better code

• Building efficient systems

• Thinking about scalability

• Understanding how products can be improved

DSA isn’t just about solving interview questions.

Link:

It develops the logic and problem-solving skills that you can apply when building real products.

6. Start Applying

Once you’ve built your skills and projects, start applying.

But don’t rely only on mass applications.

One approach is to find:

• Recruiters on LinkedIn

• Startup founders

• Engineering leaders

• Hiring managers

Then send a short, personalized message that includes your portfolio and relevant projects.

You can use the same strategy on X/Twitter as well.

The goal is simple:

Don’t just send applications. Build relationships and get your work in front of the right people.

The 2026 Tech Job Roadmap

If I had to simplify everything into one checklist:

1. Choose a language → Python or Rust
2. Build projects → Focus on end-to-end products
3. Learn AI → Understand the important concepts
4. Study system design → Learn how scalable systems work
5. Practice DSA → Strengthen your problem-solving
6. Apply strategically → Reach recruiters, founders and hiring managers

You don’t need to master everything in a week.

Pick one step, build consistency, and keep moving forward.

Learn → Build → Share → Connect → Apply.

That’s the loop.

A better approach is to find existing research, understand it, reproduce it, and then add your own contribution.

Here’s a simple 4-step process you can follow.

1. Head Over to Papers With Code

Start with Papers With Code, a platform that connects research papers with their implementations, datasets, benchmarks, and GitHub repositories.

Instead of randomly searching for project ideas, browse through research that already exists.

Look through areas you’re interested in:

• Computer Vision

• NLP

• Generative AI

• Robotics

• Reinforcement Learning

• Audio

• Multimodal AI

• Medical AI

• Time-Series

• LLMs

The goal isn’t to immediately find the “perfect” project.

You’re simply looking for interesting problems that already have enough information and code available to learn from.

2. Scroll Through and Choose ONE Project

This is where most people make a mistake.

They find 10 interesting papers, bookmark all of them, and end up building none.

Instead, pick one project.

Choose something that:

• You can somewhat understand

• Matches your current skill level

• You genuinely want to learn

• Has an available GitHub implementation

• Has enough documentation to reproduce

• Gives you room to experiment

You don’t need to understand every line of the paper before starting.

You just need to understand the problem, the basic idea, the inputs/outputs, and what the researchers are trying to achieve.

Then go through the GitHub repository carefully.

Your goal is not to blindly copy it.

Your goal is to answer:

“How does this project actually work?”

3. Use AI to Replicate and Understand It

This is where tools like ChatGPT, Claude, and Gemini become extremely useful.

Give the AI the GitHub repository and the research paper, and ask it to help you reproduce the project step by step.

Don’t ask:

“Build this entire GitHub project for me.”

Instead, use a structured master prompt that makes the AI work incrementally.

The workflow:

Repository → Understand → Plan → Implement → Test → Debug → Repeat

For example:

Phase 1: Understand the repository
↓
Phase 2: Set up the environment
↓
Phase 3: Prepare the dataset
↓
Phase 4: Implement the data pipeline
↓
Phase 5: Implement the model
↓
Phase 6: Train
↓
Phase 7: Evaluate
↓
Phase 8: Reproduce the results

After each phase, run the code yourself and verify that it works before moving forward.

This turns AI from a code generator into a research + coding mentor.

Master Prompt

I’ve created a reusable master prompt that you can paste into ChatGPT, Claude, or Gemini to guide this process:

Prompt link: Reusable Prompt

The important rule is:

One phase at a time. Understand it. Run it. Verify it. Then continue.

That way, you’re actually learning the project instead of ending up with a giant codebase you don’t understand.

4. Add Your Own Uniqueness

Now comes the most important part.

Don’t stop at reproduction.

Reproducing an existing project teaches you how the original system works.

Your contribution comes from what you do after you understand it.

You can add uniqueness in many ways:

Change the Dataset

Train or evaluate the model on a different dataset.

For example:

Original: General image classification
Your version: Classification for a specific real-world domain

Change the Model

Experiment with a different architecture, backbone, embedding model, or LLM.

Improve Performance

Try to improve:

• Accuracy

• F1 score

• Inference speed

• Memory usage

• Training efficiency

• Robustness

Add a New Feature

Turn a research implementation into something people can actually use.

For example:

Research model → Web application → Upload → Prediction → Visualization

Combine Two Ideas

Take the core idea from one paper and combine it with another technique.

For example:

Paper A’s architecture + Paper B’s training technique

Solve a Different Problem

The original research might solve a general problem.

You can adapt the same concept to a specific use case.

That’s often where interesting projects emerge.

The Formula

The entire process can be summarized as:

Research → Reproduce → Understand → Modify → Experiment → Build

Or even simpler:

Don’t reinvent the wheel. Understand the wheel, improve it, and build something useful with it.

Your final project doesn’t have to contain a completely revolutionary algorithm.

A strong project can demonstrate that you:

• Found relevant research

• Understood the underlying idea

• Reproduced the implementation

• Identified limitations

• Made meaningful modifications

• Ran experiments

• Compared results

• Built something useful

That’s far more valuable than simply cloning a GitHub repository.

The next time you’re stuck thinking:

“I don’t have any project ideas.”

Don’t start with a blank page.

Go to Papers With Code.

Find something interesting.

Pick one project.

Use AI to understand and reproduce it step by step.

Then ask yourself:

“What can I change?”

That question is where your unique project begins.

1. Directly Qualified Applicants (Experienced Silicon Candidates)

• Background: Electrical Engineering (EE), Computer Engineering (CE), Microelectronics, or Computer Science (CS).

  Greenhouse

• Key Prerequisite: Direct personal contribution to a taped-out and shipped semiconductor/ASIC design (e.g., custom AI accelerators, GPUs, TPUs, or high-performance SoCs).

  BigGo Finance

• Experience: Typically 6–8+ years in semiconductor design, silicon verification, high-speed interconnects (PCIe, CXL, SerDes), or system architecture.

2. Software Engineers & Systems Architects (Co-Design & Infra)

• Background: Systems programmers, ML infrastructure engineers, and low-level software engineers working on AI accelerators.

• Key Experience: CUDA/Triton development, AI compilers (XLA, TVM, MLIR), kernel optimization, and memory bandwidth management (KV cache, GPU interconnects).

Step-by-Step Preparation Roadmap

To prepare for roles in custom AI silicon and hardware/software co-design, focus on building skills across four core phases:

Phase 1: Core Fundamentals (Months 1–3)

• Digital Design & Architecture: Computer Architecture (Hennessy & Patterson), RISC-V ISA, RTL design (Verilog/SystemVerilog).

• VLSI & ASIC Design Flow: RTL-to-GDSII flow, synthesis, static timing analysis (STA), and functional verification.

• Low-Level Hardware Interfaces: Memory architectures (HBM3/HBM4, SRAM, DDR5), PCIe Gen 5/6, CXL, and SerDes protocols.

Phase 2: AI Accelerator Specialization (Months 4–6)

• AI Chip Architecture: Study domain-specific architectures (Google TPUs, Nvidia Blackwell, AWS Trainium, Tenstorrent).

• Workload Requirements: Analyze matrix multiplication units (Systolic Arrays), FP8/INT8 precision formats, and memory bandwidth constraints during transformer inference.

• Hardware-Software Co-Design: Understand how model quantization, sparsity, and KV-cache offloading interact directly with silicon limits.

Phase 3: Software & Compiler Layer (Months 7–9)

• Compiler Frameworks: Master MLIR (Multi-Level Intermediate Representation), TVM, and LLVM backends for AI chips.

• Kernel Development: Write custom kernels using OpenAI Triton, CUDA, or C++ to directly optimize memory access patterns.

• Profiling & Bottleneck Analysis: Use tools like Nsight Systems or custom hardware counters to isolate compute vs. memory-bound bottlenecks.

Phase 4: Production & Tape-Out Experience (Months 10+)

• Open-Source Silicon Projects: Participate in open-source ASIC projects (e.g., Tiny Tapeout, Efabless Open MPW programs, or RISC-V SoC tape-outs).

• System Bring-Up: Gain experience in silicon validation, board bring-up, and thermal/power delivery constraints (48V, liquid cooling).

  Greenhouse

Key Candidate Differentiators for Anthropic

• Tape-Out Proven Track Record: Anthropic prioritizes engineers who have taken silicon from architecture through tape-out, bring-up, and high-volume manufacturing.

  Greenhouse

• Comfort with Ambiguity: As a newly formed internal team, they favor engineers capable of making high-stakes directional decisions without waiting for large corporate consensus.

  BigGo Finance

• Mission Alignment: Beyond technical mastery, candidates must demonstrate clear alignment with AI safety and efficient deployment goals.

Anthropic hires top talent globally, and your citizenship or nationality is not a barrier. However, depending on where you are currently located, there are specific pathways and visa/location policies to keep in mind.

How It Works for Indian Applicants

1. Direct Application for US Roles (Visa Sponsorship + Relocation)

• Visa Sponsorship: Anthropic explicitly sponsors work visas (such as H-1B transfers, O-1 “Extraordinary Ability” visas, and green cards) for qualified candidates applying to US-based technical roles.

• Relocation Package: They provide comprehensive international relocation support if you are moving to San Francisco, Seattle, or New York City for the role.

• Hardware Team Location: Because the Custom Chip / Silicon Team requires access to physical test labs, hardware emulation rigs, and bring-up equipment, these roles are predominantly based out of their US offices (San Francisco, CA).

2. Roles at Global Hubs & Bangalore

• Anthropic lists office hubs in Bangalore, India, alongside London, Dublin, and Tokyo.

• While core silicon design for custom chips is anchored in the US, software infrastructure, ML systems, and research roles open up across global offices.

Tip for Applying: Anthropic focuses on demonstrated technical capability over institutional prestige—they look closely at independent research, open-source chip/compiler contributions (e.g., MLIR, Triton, RISC-V), and verifiable tape-out experience

“I completed my degree, but I still don’t know whether I should become a Software Engineer, Data Analyst, Business Analyst, Product Manager, or something else.”

If this sounds like you, you’re not alone.

Every year, millions of students graduate with a B.Tech, BCA, MCA, or B.Sc. degree, yet many struggle to answer one simple question:

“Which career path is actually right for me?”

The biggest mistake students make is choosing a career based on:

• Highest salary

• Friends’ recommendations

• Social media hype

• Random YouTube videos

• Trending technologies

Instead of understanding their own strengths.

This assessment is designed to solve exactly that.

Why Degrees Alone Are No Longer Enough

A college degree is important—but it is no longer enough to get hired.

Companies today are looking for candidates who can demonstrate real skills, not just list them on a résumé.

Current Hiring Expectations (2026)

Today’s employers expect fresh graduates to bring much more than academic knowledge.

They look for candidates who have:

• Built real-world, project-based applications instead of relying only on academic marks.

• Learned to work alongside AI tools such as GitHub Copilot, Claude, Cursor, and ChatGPT rather than fearing them.

• Developed basic system design thinking, even for entry-level software roles.

• Strong written communication and asynchronous collaboration skills using tools like Slack, Jira, Notion, and technical documentation.

• Proven ability to continuously learn because technologies evolve every 18–24 months.

• Some level of specialization rather than superficial knowledge across dozens of technologies.

For example,

“I built three production-ready Python backend projects.”

creates a much stronger impression than

“I know Python, Java, C++, SQL, JavaScript, React, AWS, Docker...”

What Companies Actually Look For in Freshers

Why It Matters:

• GitHub with consistent commits: Shows continuous learning rather than last-minute college assignments.

• 2–3 deployed projects: Demonstrates that you can complete real software, not just tutorials.

• Strong problem-solving ability: Better predictor of job performance than academic marks.

• Basic DSA knowledge: Still one of the most common technical screening criteria.

• Communication skills: Engineers spend significant time explaining ideas, writing documentation, and collaborating.

• AI fluency and curiosity: Shows adaptability in an AI-assisted workplace.

Skills vs Marks vs Certifications vs Projects

Many students ask:

“What matters most during hiring?”

Here’s the reality.

• Marks may help you get shortlisted for a few campus placements.

• Certifications show initiative but are weak signals by themselves.

• Skills determine what you are actually capable of doing.

• Projects provide proof that those skills exist.

The hiring priority looks like this:

Projects → Demonstrated Skills → Certifications → Academic Marks

That is why this assessment—and this entire career roadmap—is built around skills and execution, not grades.

Before You Start

This assessment is designed to help you decide between a coding-focused and a non-coding technology career.

Please answer honestly.

Don’t choose the answer you wish were true.

Choose the answer that best describes you today.

Scoring Instructions

Each question has four options.

• A = 4 points

• B = 3 points

• C = 2 points

• D = 1 point

At the end of every section:

1. Calculate your score.

2. Multiply it by the section weight.

3. Add all section scores together.

Your final score will help determine which technology career is naturally aligned with your interests and strengths.

1. Interest in Programming

Question 1

When you see broken code, your first instinct is:

• A. Excited to debug it

• B. Willing to try

• C. Prefer someone else fixes it

• D. Actively avoid it

Question 2

Have you ever built something outside a college assignment simply because you were curious?

• A. Regularly

• B. A few times

• C. Once or twice

• D. Never

Question 3

How do you feel about spending three hours debugging an error?

• A. Energized by the challenge

• B. It’s part of the job

• C. Draining but manageable

• D. I’d rather quit

2. Logical Reasoning

Question 1

Puzzle or aptitude questions feel:

• A. Fun

• B. Manageable

• C. Slow

• D. Confusing

Question 2

Can you break a complex problem into smaller tasks?

• A. Easily

• B. Usually

• C. Sometimes

• D. Rarely

Question 3

Pattern-recognition questions are:

• A. Easy

• B. Comfortable

• C. Difficult

• D. Very difficult

3. Communication Skills

Question 1

Explaining technical ideas to non-technical people is:

• A. Natural

• B. Comfortable

• C. Difficult

• D. Something I avoid

Question 2

During group discussions you usually:

• A. Lead

• B. Contribute actively

• C. Participate reluctantly

• D. Stay silent

Question 3

Writing documentation or professional emails is:

• A. One of my strengths

• B. Comfortable

• C. Difficult

• D. A struggle

4. Creativity

Question 1

Open-ended problems are:

• A. My favorite

• B. Interesting

• C. I prefer structure

• D. Uncomfortable

Question 2

Do you think of multiple ways to solve the same problem?

• A. Constantly

• B. Often

• C. Occasionally

• D. Rarely

Question 3

Design, colors, and layouts catch your attention:

• A. Always

• B. Sometimes

• C. Rarely

• D. Never

5. Mathematics Comfort Level

Question 1

How comfortable are you with algebra, probability, and statistics?

• A. Strong

• B. Above average

• C. Below average

• D. Weak

Question 2

Working with formulas feels:

• A. Comfortable

• B. Manageable

• C. Difficult

• D. I avoid it

Question 3

Would you enjoy solving quantitative problems every day?

• A. Absolutely

• B. I wouldn’t mind

• C. Prefer less

• D. Definitely not

6. Problem Solving

Question 1

When faced with an unfamiliar problem, you:

• A. Experiment immediately

• B. Research first

• C. Search for templates

• D. Feel stuck

Question 2

Debugging a difficult issue feels:

• A. Exciting

• B. Challenging but satisfying

• C. Frustrating

• D. Something I’d rather avoid

Question 3

Ambiguous instructions:

• A. Don’t bother me

• B. I ask one question then continue

• C. I need more clarity

• D. I cannot proceed

7. Business Understanding Question 1

Do you naturally ask why a feature exists?

• A. Always

• B. Often

• C. Rarely

• D. Never

Question 2

Reading about startups and business interests you:

• A. Very much

• B. Sometimes

• C. Neutral

• D. Not at all

Question 3

Would you enjoy bridging business and technology?

• A. Absolutely

• B. Maybe

• C. Probably not

• D. Definitely not

8. Data Interpretation

Question 1

Reading charts and graphs:

• A. Easy

• B. Comfortable

• C. Difficult

• D. Confusing

Question 2

Working with Excel spreadsheets:

• A. Comfortable

• B. Basic

• C. Rare

• D. Never

Question 3

Would you enjoy finding patterns in data every day?

• A. Yes

• B. Maybe

• C. Not really

• D. No

9. Presentation Skills

1. Do you enjoy creating presentations?

2. Are you comfortable speaking in front of people?

3. Can you persuade others with structured arguments?

Use the same A–D scoring scale.

10. Learning Style

1. How do you learn best?

2. How comfortable are you with self-paced learning?

3. What do you do when stuck?

Score using A–D.

11. Personality Type

1. Solo work or teamwork?

2. How do you handle deadlines?

3. Which describes you best: Analytical, Balanced, Expressive, or People-first?

12. Preferred Work Environment

1. What does your ideal workday look like?

2. Do you enjoy remote, asynchronous work?

3. Do you prefer measurable technical output over relationship-based work?

13. Long-Term Career Goals

1. Where do you see yourself in five years?

2. Does entrepreneurship interest you?

3. Which matters more: technical expertise or business skills?

Once you’ve calculated your total score, you’ll discover whether you’re naturally suited for:

• Software Development

• Data Analytics

• Machine Learning & AI

• Cloud & DevOps

• Business Analysis

• UI/UX Design

• Digital Marketing

• Product Management

• Technical Recruitment

• Cybersecurity

In the next article, we’ll explain exactly how to interpret your score and recommend the best career path based on your strengths, interests, and long-term goals—along with a step-by-step six-month roadmap to become job-ready.

There is no “best” career.

There is only the career that aligns with your strengths, personality, interests, and learning style.

Don’t chase trends.

Build skills.

Create projects.

Stay curious.

And let your work speak louder than your résumé.

This roadmap is designed for:

• College students preparing for placements

• Software Engineers transitioning into Machine Learning

• Data Analysts moving toward ML Engineering

• Working professionals preparing for Machine Learning interviews

Unlike many roadmaps that simply list technologies, this guide follows the actual learning sequence used by successful Machine Learning Engineers working at startups and large technology companies.

If you study consistently, build projects, and practice interviews, this roadmap can be completed in approximately 6–12 months, depending on your background.

1. Build a Strong Python Foundation

Python is the primary programming language for Machine Learning. Before learning algorithms, you should become comfortable writing clean, efficient, and reusable Python code.

Focus on learning:

• Python syntax and best practices

• Functions and modular programming

• Object-Oriented Programming (OOP)

• Iterators and Generators

• Decorators

• Context Managers

• Exception Handling

• File Handling

• Virtual Environments

• pip and dependency management

• Memory Management

• Multiprocessing vs Multithreading

• Asynchronous Programming

Project

Build and publish your own Python package.

2. Learn Git, GitHub and Linux

Every Machine Learning Engineer collaborates with teams using Git and works on Linux-based systems.

Learn:

• Git fundamentals

• Branching strategies

• Merge conflicts

• Pull Requests

• GitHub workflows

• Linux file system

• Common terminal commands

• Shell scripting

• SSH

• Cron Jobs

Project

Deploy a Machine Learning application entirely from the terminal.

3. Master Mathematics for Machine Learning

You do not need to become a mathematician, but you should understand the intuition behind the algorithms you use.

Linear Algebra

Study:

• Vectors

• Matrices

• Matrix Multiplication

• Matrix Inverse

• Eigenvalues

• Eigenvectors

• Singular Value Decomposition (SVD)

Calculus

Learn:

• Derivatives

• Partial Derivatives

• Chain Rule

• Gradient Descent

• Optimization

Probability

Understand:

• Conditional Probability

• Bayes’ Theorem

• Random Variables

• Probability Distribution Functions (PDF)

• Cumulative Distribution Functions (CDF)

• Expectation

Statistics

Focus on:

• Mean

• Median

• Mode

• Variance

• Standard Deviation

• Covariance

• Correlation

• Hypothesis Testing

• Confidence Intervals

link: https://github.com/Akansha-yadav24/Machine-Learning-with-Python-by-Codingdidi/blob/main/%232%20maths.md

4. Become Comfortable with NumPy

NumPy forms the foundation of almost every Machine Learning library.

Learn:

• ndarray

• Array creation

• Broadcasting

• Views vs Copies

• Advanced Indexing

• Boolean Masking

• Vectorization

• Random Module

• Linear Algebra Operations

Project

Implement common matrix operations without using high-level libraries.

Free Resource

NumPy Complete Course:

5. Learn Data Analysis with Pandas

Real-world datasets are messy. Most of your time as an ML Engineer will be spent preparing data.

Focus on:

• Reading datasets

• Data Cleaning

• Missing Values

• Filtering

• Sorting

• GroupBy

• Merge

• Join

• Pivot Tables

• Window Functions

• Time Series

• Feature Creation

Project

Perform a complete Exploratory Data Analysis (EDA) on a real-world dataset.

Free Resource

Complete Pandas Course:

6. Learn Data Visualization

Visualization helps you understand data before building models.

Learn:

• Matplotlib

• Seaborn

• Plotly

Project

Create an interactive dashboard for a real dataset.

7. Master SQL

SQL remains one of the most important interview skills for Machine Learning Engineers.

Study:

• SELECT queries

• Filtering

• Aggregations

• Joins

• GROUP BY

• HAVING

• Window Functions

• Common Table Expressions (CTEs)

• Stored Procedures

• Indexes

• Query Optimization

Practice SQL interview questions regularly.

8. Understand Machine Learning Fundamentals

Before jumping into algorithms, understand how Machine Learning works.

Learn:

• Machine Learning workflow

• Training vs Testing

• Bias vs Variance

• Overfitting

• Underfitting

• Cross Validation

• Evaluation Metrics

• Data Leakage

9. Learn Supervised Learning

Begin with regression before moving to classification problems.

Regression

Study:

• Linear Regression

• Ridge Regression

• Lasso Regression

• ElasticNet

Classification

Learn:

• Logistic Regression

• Naive Bayes

• K-Nearest Neighbors (KNN)

• Support Vector Machines (SVM)

10. Learn Tree-Based Algorithms

Tree-based models dominate many real-world Machine Learning competitions.

Study:

• Decision Trees

• Random Forest

• Extra Trees

• XGBoost

• LightGBM

• CatBoost

Project

Participate in a Kaggle competition using gradient boosting models.

11. Learn Unsupervised Learning

Not all datasets contain labels.

Learn:

• K-Means Clustering

• Hierarchical Clustering

• DBSCAN

• Principal Component Analysis (PCA)

• t-SNE

• UMAP

12. Master Feature Engineering

Good features often outperform complex algorithms.

Learn:

• Encoding techniques

• Feature Scaling

• Missing Value Imputation

• Feature Selection

• Feature Extraction

• Dimensionality Reduction

13. Learn Model Evaluation and Explainability

Choosing the right metric is as important as choosing the right model.

Study:

• Accuracy

• Precision

• Recall

• F1 Score

• ROC Curve

• Precision-Recall Curve

• Matthews Correlation Coefficient (MCC)

Understand explainability using:

• SHAP

• LIME

14. Learn Deep Learning with PyTorch

PyTorch has become the preferred framework for research and production.

Study:

• Tensors

• Autograd

• Dataset

• DataLoader

• Training Loop

• CNN

• RNN

• LSTM

• GRU

• Attention Mechanism

15. Learn Transformers

Transformers power modern AI applications.

Study:

• Self Attention

• Multi-Head Attention

• Positional Encoding

• Encoder Architecture

• Decoder Architecture

• BERT

• GPT

16. Learn Natural Language Processing

Modern NLP combines classical methods with transformer-based models.

Learn:

• Tokenization

• TF-IDF

• Word2Vec

• FastText

• Embeddings

• Hugging Face Transformers

17. Learn Computer Vision

Computer Vision continues to be one of the highest-demand ML domains.

Study:

• OpenCV

• Image Classification

• Object Detection

• Image Segmentation

• CNN Architectures

18. Learn Time Series Forecasting

Forecasting is widely used in finance, retail, logistics, and healthcare.

Learn:

• ARIMA

• Prophet

• LSTM Forecasting

• Feature Engineering for Time Series

19. Learn Recommendation Systems

Recommendation engines power companies like Netflix, YouTube, Spotify, and Amazon.

Study:

• Collaborative Filtering

• Matrix Factorization

• Ranking Models

20. Learn Machine Learning System Design

Building models is only part of the job. Production systems require scalable architecture.

Understand:

• Feature Stores

• Data Pipelines

• Batch Processing

• Streaming Pipelines

• Online Prediction

• Model Monitoring

• Drift Detection

• Retraining Strategies

21. Learn MLOps

Deploying Machine Learning models is an essential engineering skill.

Study:

• Docker

• Kubernetes

• MLflow

• DVC

• Apache Airflow

• FastAPI

• CI/CD

• Model Monitoring

Project

Build and deploy a complete production Machine Learning pipeline.

22. Learn LLM Engineering

Large Language Models have become a core skill for modern Machine Learning Engineers.

Study:

• Transformer Architecture

• LoRA

• QLoRA

• PEFT

• Quantization

• Retrieval-Augmented Generation (RAG)

• Vector Databases

• LangChain

• LlamaIndex

• Model Context Protocol (MCP)

• AI Agents

Project

Build a production-ready RAG chatbot with document ingestion, retrieval, and evaluation.

23. Practice Machine Learning System Design Interviews

Be prepared to discuss how you would design scalable ML systems.

Practice designing:

• YouTube Recommendation System

• Spam Detection System

• Fraud Detection Platform

• Search Ranking Engine

• Real-Time Recommendation System

24. Prepare for Coding Interviews

Most Machine Learning Engineer interviews still include coding rounds.

Practice:

• Arrays

• Strings

• Hash Maps

• Trees

• Graphs

• Dynamic Programming

• Sliding Window

• Two Pointers

Solve problems consistently on LeetCode.

25. Prepare for Machine Learning Interviews

Interview preparation should cover theory, coding, and system design.

Practice:

• Machine Learning theory questions

• Python coding questions

• SQL interview questions

• Statistics questions

• ML system design questions

• Behavioral and HR interview questions

Aim to solve at least 300 interview questions before appearing for interviews.

26. Build Production-Ready Portfolio Projects

Projects are the strongest proof of your skills. Focus on solving real-world problems rather than reproducing tutorial code.

Build projects such as:

• House Price Prediction API

• Customer Churn Prediction

• Credit Risk Prediction

• Resume Screening System

• Fake News Detection

• Sentiment Analysis

• Image Classification

• Object Detection

• Recommendation Engine

• Time Series Forecasting

• Real-Time Fraud Detection

• Production RAG Chatbot

• AI Resume Reviewer

• Voice Assistant

• Multi-Agent AI System

Each project should include:

• Well-documented GitHub repository

• Clean code structure

• Docker support

• REST API

• Deployment

• Unit tests

• README with architecture diagrams

Final Thoughts

Becoming a Machine Learning Engineer is not about memorizing algorithms—it’s about learning how to solve real-world problems using data, software engineering, and production-ready AI systems.

Take your time, build projects, document your learning publicly, contribute to open source, participate in Kaggle competitions, and continuously refine your engineering skills.

Technology will continue to evolve, but a strong foundation in Python, mathematics, Machine Learning, software engineering, and problem-solving will remain valuable throughout your career.

If you follow this roadmap consistently, you’ll not only prepare for interviews but also build the practical skills required to become a successful Machine Learning Engineer.

Best for: Absolute beginners

✅ Real-world datasets
✅ Learn from public notebooks
✅ Free participation
✅ Beginner competitions available

Start with:

• Titanic Survival Prediction

• House Prices Prediction

• Digit Recognizer

Why?
You’ll learn data cleaning, feature engineering, model building, and leaderboard strategies.

2. Analytics Vidhya DataHack

Best for: Indian students

✅ Beginner-friendly challenges
✅ Active community
✅ Good learning resources
✅ Recruiters often notice top performers

Popular domains:

• Machine Learning

• NLP

• Computer Vision

• Recommendation Systems

3. MachineHack

Best for: Practice before Kaggle

✅ Short competitions
✅ Easier datasets
✅ Great for building confidence
✅ Certificates available

4. Devfolio Hackathons

Best for: AI project building

Instead of just training models, you’ll build:

• AI applications

• Chatbots

• Recommendation systems

• Computer Vision projects

Good for portfolio projects.

5. MLH (Major League Hacking)

Best for: College students

✅ Team-based
✅ Beginner workshops
✅ Industry mentors
✅ International participation

6. Google Kaggle AI Competitions

Best for: Intermediate beginners

Many competitions are sponsored by Google and industry partners.

Prize pools can range from a few hundred dollars to tens of thousands.

7. Zindi Africa Competitions

Best for: Real-world ML problems

Work on:

• Healthcare

• Agriculture

• Finance

• Climate

Excellent for practical experience.

📅 Beginner Roadmap

Month 1

• Learn Python + Pandas + NumPy

• Complete Titanic Competition

Month 2

• Join MachineHack competitions

• Build 2–3 notebooks

Month 3

• Participate in Analytics Vidhya DataHack

Month 4+

• Join Kaggle Featured Competitions

• Participate in AI Hackathons on Devfolio

Portfolio Goal

By the end of your first 3–4 months, try to have:

• 3 Kaggle notebooks

• 2 competition submissions

• 1 end-to-end ML project

• 1 hackathon participation certificate

• GitHub portfolio showcasing all work

This combination is often more valuable for internships and entry-level ML roles than collecting many online certificates.

You’re six months into your first real job. Your manager drops a ticket in your queue — a bug buried three layers deep in a service you didn’t write. You open Cursor. You paste the error. The AI gives you a fix in eleven seconds. You apply it. Tests pass. You close the ticket.

That feeling — the slight unease that follows — has no name yet. It’s not imposter syndrome. It’s something quieter and more specific. It’s the feeling of having solved something you don’t understand.

Nobody talks about that feeling. Instead, they tell you this is the future. The industry has reached a consensus so fast it barely had time to be debated: the age of writing code is over. The new skill is judgment. Taste. Architecture. Knowing what to build and why. Senior engineers at Spotify haven’t written a line of code since December. Boards are asking CTOs about their “AI strategy.” Y Combinator startups are shipping 95% AI-generated codebases. The message from every direction is identical — stop implementing, start directing.

It sounds right. It feels like progress. It might be the most dangerous idea in tech right now.

Here’s what the industry is quietly skipping over: nobody knows how to teach judgment. We know how to describe it. We know how to value it. We can all agree it’s the thing that makes a senior engineer irreplaceable. But we have never — not once in the history of software — produced a developer who had it without first spending years in the uncomfortable middle layer of actually building things, breaking things, and understanding why they broke.

The math of machine learning gives us a useful parallel. A model doesn’t learn to generalise by being told to generalise. It generalises by processing thousands of examples until something in the weights — something we still can’t fully explain or extract — begins to encode the underlying structure of the problem. Remove the examples, hand it the answer key, and it memorises. It can pass the test. It cannot handle the next problem it has never seen.

Junior developers using AI all day are doing exactly this. A 2026 study from ICSE found that developers who rely heavily on AI code generation are accumulating what researchers now call “epistemic debt” — a growing gap between the complexity of the systems they ship and their cognitive grasp of what those systems actually do. Meanwhile, 66% of developers say they are spending more time debugging AI-generated code than writing their own — which sounds like inefficiency but is actually something worse. It is the experience of being responsible for decisions you didn’t make, in systems you didn’t fully design, that behave in ways you didn’t predict.

That is not how judgment forms. That is how anxiety forms.

Judgment, as any experienced engineer will tell you off the record, is mostly scar tissue. It’s the memory of the database migration that wiped production data. It’s the API design you were proud of until six months later when you tried to extend it and couldn’t. It’s the refactor that introduced three bugs for every one it fixed. These experiences don’t just teach you what went wrong. They build an internal model of systems — a feel for fragility, a nose for the kind of cleverness that ages badly. That intuition lives in your hands before it lives in your head.

We built AI to remove the slow, painful parts of learning. Those slow, painful parts were the learning.

The industry’s response to this is “pair junior developers with seniors.” Let AI handle the boilerplate, let humans handle judgment, and use mentorship to transfer wisdom downward. It’s a reasonable prescription that misunderstands how wisdom transfers. Seniors don’t teach judgment by explaining it. They teach it by watching someone struggle with a real problem and knowing when to let them struggle longer. That pedagogical tension — the deliberate withholding of the answer — is precisely what AI collapses. The moment struggle becomes optional, most people stop struggling.

Microsoft’s Russinovich and Hanselman, writing in the April 2026 Communications of the ACM, put it plainly: early-career developers must not be shielded from the problem-solving process. They are being shielded from it every day, by tools they were told would make them more powerful.

This is the paradox nobody in the “learn judgment, not syntax” conversation wants to name directly. We built AI to compress the path from beginner to productive. The path we compressed was the exact terrain on which judgment was built.

In ten years, the most valuable engineers won't be the ones who learned to direct AI the earliest. They'll be the ones who, somewhere along the way, did something the machines made optional — they stayed in the problem long enough to understand it. And in a world where that choice is voluntary, almost nobody will make it. The developers who do will be indistinguishable from what we used to simply call wise.

Variables.
Loops.
Functions.
OOP.
Libraries.
Projects.

A few weeks later, they’re overwhelmed and quit.

I know this because I’ve seen it happen again and again.

That’s why I built Python with CodingDidi.

Instead of throwing 100 topics at you, the course focuses on building a strong foundation first—understanding how Python actually works and learning through code, not memorization.

Inside the course you’ll learn:

→ Python fundamentals from scratch
→ Loops, functions, and problem-solving
→ Object-Oriented Programming (OOP)
→ Practical coding exercises
→ Real-world examples and projects

The goal isn’t just to finish another course.

The goal is to become confident enough to write your own programs.

Python is the entry point to Data Science, AI, Automation, Machine Learning, and Software Development.

Every expert started with their first print statement.

Today might be a good day to write yours.

Course: Python with CodingDidi

What are you currently learning with Python?

And honestly…

This role is where engineering + product thinking + real-world AI deployment all meet together.

So… What Exactly Is a Forward Deployed Engineer?

A forward deployed engineer is someone who works directly with customers to solve real-world problems using

• Software

• AI systems

• Data infrastructure

• Automation workflows

• LLM applications

Instead of just building products internally…

FDEs go directly into the battlefield of production systems.

They:

• Understand customer pain points

• Build solutions rapidly

• Deploy AI into real businesses

• Integrate messy enterprise systems

• Ship production-ready workflows

Think of them as:

Software Engineer + AI Engineer + Product Thinker + Customer Engineer

Why This Role Exists

Traditional software engineering often looks like this:

Build feature → Push code → Done

But enterprise AI doesn’t work that way.

Real companies have:

• Bad data

• Legacy systems

• Security restrictions

• Weird workflows

• Non-technical teams

• Complex integrations

So companies needed engineers who could:

• Talk to customers

• Understand business logic

• Build fast

• Deploy AI systems

• Solve real operational problems

That’s how the FDE role was born.

What Does an FDE Actually Do?

1. Customer Problem Solving

An FDE spends a lot of time understanding:

• What problem the customer has

• Why current systems fail

• Where AI can help

• What workflow needs automation

Example:

A hospital wants:

• AI-generated patient summaries

• Faster report analysis

• Medical document search

The FDE designs:

• LLM workflow

• Retrieval system

• API integration

• Deployment pipeline

2. Rapid Prototyping

FDEs build FAST.

Not “6-month enterprise development” fast.

More like:

“Can we demo this in 48 hours?”

They create:

• MVPs

• Internal tools

• AI copilots

• Automation systems

• Custom dashboards

Typical stack:

• Python

• FastAPI

• React

• Docker

• LangChain

• Vector DBs

• Cloud infrastructure

3. AI Deployment in Real Production

This is where things become difficult.

Building AI demos is easy.

Deploying AI into:

• banks

• hospitals

• defense systems

• enterprise software

…is HARD.

FDEs handle:

• Authentication

• APIs

• Security

• Scaling

• Monitoring

• Production debugging

This is why companies value them heavily.

4. Communication Is a Core Skill

A normal engineer may mostly interact with code.

An FDE interacts with:

• Customers

• Executives

• Product teams

• Researchers

• Designers

• Operations teams

They must explain:

• technical ideas simply

• AI limitations clearly

• deployment tradeoffs practically

This role rewards people who can both:

code deeply AND communicate clearly

Why AI Companies Love FDEs

Modern AI companies don’t just sell models.

They sell:

• workflows

• automation

• intelligence systems

• business outcomes

And customers rarely know how to integrate AI properly.

That’s where FDEs become critical.

Companies like:

• Palantir

• OpenAI

• Scale AI

• Anthropic

• Anduril

…all heavily rely on engineers who can deploy AI into real-world environments.

Who Should Become an FDE?

You’ll probably LOVE this role if you:

• Enjoy building fast

• Like solving messy problems

• Want ownership

• Enjoy startups

• Like AI deployment

• Love product thinking

• Can communicate well

You may dislike it if you:

• Prefer isolated coding

• Hate meetings

• Want predictable work

• Don’t enjoy ambiguity

Skills Required to Become an FDE

Core Engineering Skills

You need strong fundamentals in:

• Python

• APIs

• Backend development

• Databases

• Cloud systems

• Docker/Kubernetes

• System design

AI Skills

Modern FDE roles increasingly require:

• LLMs

• RAG pipelines

• Prompt engineering

• AI agents

• Vector databases

• Model deployment

Soft Skills

This role strongly rewards:

• Communication

• Fast execution

• Ownership

• Adaptability

• Product thinking

The Most Important Part: Thinking Like an Engineer

The best FDEs don’t just ask:

“Can we build this?”

They ask:

• Should we build this?

• Will users actually use it?

• Can it scale?

• Is the workflow practical?

• Will deployment fail in production?

That mindset is extremely valuable in AI.

Typical Day of an FDE

Morning:

• Customer call about AI search issues

Afternoon:

• Build retrieval pipeline using embeddings

Evening:

• Deploy updated workflow

• Demo solution to client

Every day is different.

That’s why many engineers love the role.

Salary Potential

Because this role combines:

• engineering

• deployment

• communication

• AI systems

• customer problem solving

…it’s becoming one of the highest-paying engineering roles.

Approximate ranges:

India

₹20L → ₹80L+

US

$150k → $400k+

Especially in AI infrastructure companies.

How To Become an FDE

Step 1 — Become Strong at Software Engineering

Learn:

• Python

• APIs

• Backend systems

• Databases

• Cloud deployment

Step 2 — Learn AI Engineering

Focus on:

• LLMs

• RAG

• Vector databases

• AI agents

• Deployment pipelines

Step 3 — Build Real Projects

Best projects:

• AI chatbot

• Document Q&A

• AI workflow automation

• Enterprise copilots

• Customer support AI

Step 4 — Improve Communication

Practice:

• Explaining systems simply

• Writing documentation

• Giving demos

• Talking to non-technical people

This is a SUPER underrated skill.

Final Thoughts

The AI industry is slowly realizing something important:

The hardest part is not building models anymore.

The hardest part is:

• deploying them

• integrating them

• making them useful in real businesses

That’s exactly what Forward Deployed Engineers do.

And over the next few years…

This role may become one of the most important positions in the AI ecosystem.

Recommended Learning Resources

Backend + Systems

• FastAPI Official Docs
  Best for learning modern Python backend APIs.

• System Design Primer GitHub
  One of the best free resources for scalable system design interviews and architecture.

• Docker Official Docs
  Learn containers, Dockerfiles, networking, and deployment.

• Kubernetes Official Docs
  Learn orchestration, scaling, pods, services, and production deployments.

AI Engineering

• LangChain Docs
  Build AI agents, RAG systems, tools, workflows, and LLM apps.

• LlamaIndex Official Docs
  Great for document Q&A systems and retrieval pipelines.

• Hugging Face Course
  Complete free course on Transformers, NLP, tokenization, fine-tuning, and LLMs.

Real-World AI

• OpenAI API Docs
  Learn APIs, function calling, agents, embeddings, and production AI workflows.

• Anthropic Docs
  Learn Claude APIs, prompt engineering, tools, and enterprise AI usage.

Bonus Resources (Highly Recommended)

• Full Stack Deep Learning
  Real-world production AI engineering course.

• Weights & Biases Courses
  MLOps, experiment tracking, and LLMOps.

• Microsoft GenAI for Beginners GitHub
  Beginner-friendly practical GenAI course.

• Sebastian Raschka LLM Book Repository
  Build LLMs from scratch step-by-step.

• Awesome LLM Apps GitHub
  Collection of production-ready AI projects and agents.

How does ChatGPT actually generate human-like responses?

How does it understand context?
How does it predict the next word?
How does it remember the flow of a conversation?

And that’s where the real AI engineering journey begins.

AI User vs AI Engineer

Most people today are becoming AI users.

Very few are becoming AI engineers.

Using prompts is easy.
Building understanding is hard.

If you truly want to master Large Language Models (LLMs), you need to understand what’s happening under the hood.

Not just:

“Write me code.”

But:

“How does the model know what code to write?”

Step 1 — Understanding NLP (Natural Language Processing)

Before LLMs, there was NLP.

NLP is the field that teaches machines how to work with human language.

This includes tasks like:

• Text Classification

• Translation

• Summarization

• Sentiment Analysis

• Question Answering

But machines don’t understand text naturally.

First, text must be processed.

Step 2 — Text Processing

Raw text is messy.

So before training any AI model, we preprocess it.

This includes:

Tokenization

Breaking sentences into smaller pieces called tokens.

Example:

“I love AI”

Becomes:

[”I”, “love”, “AI”]

Lowercasing

Converting all text to lowercase for consistency.

Stopword Removal

Removing common words like:

• is

• the

• and

because they often add little meaning.

Stemming & Lemmatization

Converting words into root forms.

Examples:

• Running → Run

• Studies → Study

This helps models understand meaning better.

Step 3 — Text Representation

Machines cannot directly understand words.

They only understand numbers.

So we convert text into vectors.

Early NLP used methods like:

Bag of Words (BoW)

Counts how many times words appear.

Simple but loses context.

TF-IDF

Finds important words by measuring:

• frequency in a document

• rarity across documents

Better than BoW, but still limited.

Step 4 — Word Embeddings

This changed everything.

Instead of sparse vectors, words became dense vectors with meaning.

Now models could understand:

• semantic similarity

• relationships

• context

Example:

King - Man + Woman ≈ Queen

That’s the power of embeddings.

Popular embedding models:

• Word2Vec

• GloVe

• FastText

And techniques like:

• CBOW

• Skip-Gram

These laid the foundation for modern LLMs.

Step 5 — Transformers Changed AI Forever

Then came the biggest breakthrough:

Transformers.

The architecture behind:

• ChatGPT

• Gemini

• Claude

• Llama

Transformers solved one major problem:

Understanding long-range context efficiently.

Before transformers:

• RNNs were slow

• LSTMs struggled with long dependencies

Transformers introduced:

Attention Mechanism

The model learns:

Which words should pay attention to which other words.

This is why ChatGPT can:

• continue conversations

• understand context

• generate coherent responses

Step 6 — Pre-training and Fine-tuning

LLMs are trained in two stages.

Pre-training

The model reads massive internet-scale data and learns language patterns.

It basically becomes:

“A next-word prediction machine.”

Example:

“Machine learning is…”

The model predicts the next likely word.

This happens billions of times during training.

Fine-tuning

After pre-training, the model is specialized.

For example:

• coding assistant

• medical chatbot

• customer support AI

This stage aligns the model toward specific tasks.

Step 7 — Inference and Text Generation

This is the part most people use daily.

When you type a prompt into ChatGPT, the model generates responses token by token.

But how does it decide the next word?

Using decoding strategies.

Greedy Search

Chooses the highest probability word every time.

Fast, but repetitive.

Beam Search

Explores multiple possible sequences before choosing the best one.

Better quality, but slower.

Temperature

Controls randomness.

• Low temperature → deterministic

• High temperature → creative

Top-K Sampling

Chooses from the top K probable words only.

Helps maintain quality while adding variation.

Top-P Sampling

Chooses from the smallest set of words whose cumulative probability reaches P.

This is commonly used in modern LLMs because it balances:

• creativity

• coherence

very effectively.

The Realization Most Beginners Miss

LLMs are not “thinking.”

They are:

• probability engines

• pattern learners

• sequence predictors

But because they are trained on enormous data with transformer architectures, they appear intelligent.

And that illusion is powerful enough to change industries.

My Recommended Resources to Learn LLMs Deeply

If you genuinely want to master LLMs instead of just using them, start here:

1. Karpathy GPT Playlist- Link

Best for understanding transformers intuitively.

2. Hugging Face LLM Course- Link

Practical and beginner-friendly.

3. Stanford CS25 Transformers Course- Link

Deep theoretical understanding directly from researchers.

The AI revolution is not slowing down.

The difference in the next few years will be simple:

• People who use AI
  vs

• People who understand AI

And the second category will build the future.

So don’t just become an AI consumer.

Become someone who understands how intelligence is engineered.

But there’s one big problem:

Most people trying to become AI Engineers are learning random tools without understanding why they exist.

They jump from:

• Python tutorials

• LangChain videos

• Hugging Face demos

• Agent frameworks

• RAG tutorials

…without understanding the actual architecture of modern AI systems.

This article fixes that.

By the end, you’ll understand:

• What an AI Engineer actually does

• What to learn

• Why each skill matters

• How the entire AI ecosystem connects together

First: What Is an AI Engineer?

An AI Engineer is someone who can build intelligent systems end-to-end.

Not just train models.

Not just write prompts.

Not just use ChatGPT APIs.

A real AI Engineer can:

• Build AI products

• Create LLM applications

• Design RAG systems

• Fine-tune models

• Deploy scalable APIs

• Build AI agents

• Optimize inference

• Handle production traffic

• Connect AI with databases, cloud, and frontend apps

Think of it like this:

A Data Scientist analyzes data.
A Research Scientist invents models.
An AI Engineer builds AI systems people actually use.

Stage 1 — Learn Programming First

Learn Python

This is your foundation.

Why?

Because almost the entire AI ecosystem runs on Python.

Libraries like:

• PyTorch

• TensorFlow

• Hugging Face

• LangChain

• FastAPI

• NumPy

…all revolve around Python.

Without strong Python:

• You cannot read AI codebases

• You cannot debug models

• You cannot build production pipelines

Focus Areas

Learn:

• Variables

• Functions

• Loops

• OOP

• File handling

• APIs

• Async programming

• Error handling

Then move into:

• Data structures

• Memory optimization

• Decorators

• Generators

• Multithreading

Because production AI systems are engineering-heavy.

Stage 2 — Learn Mathematics (Yes, It Matters)

Many people try to skip math.

Bad idea.

You don’t need PhD-level mathematics.

But you must understand:

• Linear algebra

• Probability

• Statistics

• Optimization

Why?

Because AI models are mathematical systems.

For example:

• Embeddings = vectors

• Attention = matrix operations

• Training = optimization

• Gradient descent = calculus

• Similarity search = geometry

Without math:

• You memorize

• You don’t understand

And memorization breaks quickly in AI because the field evolves every month.

Stage 3 — Learn Data Handling

AI is built on data.

If you cannot work with data, you cannot build AI systems.

Learn:

• SQL

• Pandas

• NumPy

• Data cleaning

• Feature engineering

Why SQL matters:

Most real-world AI problems involve:

• Databases

• Warehouses

• Logs

• User analytics

• Product metrics

Even LLM systems eventually connect back to structured data.

Stage 4 — Learn Machine Learning Properly

Before jumping into LLMs, understand classical ML.

Why?

Because ML teaches the fundamentals of:

• Training

• Overfitting

• Bias/variance

• Evaluation

• Optimization

Learn:

• Regression

• Classification

• Clustering

• Decision trees

• Ensemble learning

Use:

• Scikit-learn

• XGBoost

• LightGBM

This stage teaches you how models actually learn patterns.

Stage 5 — Deep Learning Changes Everything

This is where AI becomes truly powerful.

Deep Learning introduced:

• Neural networks

• CNNs

• RNNs

• Transformers

• LLMs

Now you begin learning:

• PyTorch

• TensorFlow

• Backpropagation

• GPU training

• CUDA basics

Why PyTorch Matters

PyTorch became the industry standard because:

• Flexible

• Research-friendly

• Huge ecosystem

• Used by top labs

Almost every modern AI breakthrough is implemented in PyTorch first.

Stage 6 — Understand Transformers Deeply

This is the most important architecture in modern AI.

Transformers power:

• ChatGPT

• Claude

• Gemini

• Llama

• Mistral

• Copilot

You must deeply understand:

• Attention

• Self-attention

• Multi-head attention

• Embeddings

• Positional encoding

• Encoder-decoder architecture

• Tokenization

• Context windows

Because modern AI engineering is essentially:

“Engineering around transformer systems.”

Stage 7 — Learn LLM Engineering

Now we enter modern AI engineering.

This includes:

• Prompt engineering

• Context engineering

• RAG systems

• Function calling

• Tool usage

• Agent workflows

• Memory systems

Important Libraries

Learn:

• LangChain

• LlamaIndex

• DSPy

• Hugging Face Transformers

But remember:

Frameworks change fast.

Concepts matter more than tools.

Stage 8 — Learn RAG (Retrieval-Augmented Generation)

RAG is one of the most important production AI architectures.

Why?

Because LLMs forget information and hallucinate.

RAG solves this by:

1. Retrieving external data

2. Injecting it into the prompt

3. Generating grounded answers

This powers:

• AI chatbots

• Enterprise search

• AI copilots

• Knowledge assistants

Learn:

• Embeddings

• Chunking

• Vector databases

• Similarity search

• Hybrid retrieval

• Re-ranking

Important Vector DBs

• Pinecone

• FAISS

• Weaviate

• Qdrant

• ChromaDB

Stage 9 — Learn AI Agents

This is where the industry is moving rapidly.

An AI Agent is an LLM that can:

• Reason

• Use tools

• Execute actions

• Plan tasks

• Maintain memory

Modern AI agents can:

• Browse the web

• Write code

• Call APIs

• Analyze files

• Coordinate with other agents

Learn:

• LangGraph

• CrewAI

• AutoGen

• OpenAI Agents SDK

But more importantly:
Learn orchestration and system design.

Because real agents are workflow systems.

Stage 10 — Learn Backend Engineering

Most beginners ignore this.

Huge mistake.

Your AI model is useless if nobody can access it.

You must learn:

• APIs

• Authentication

• WebSockets

• Async systems

• Streaming responses

Important Frameworks

• FastAPI

• Flask

• Node.js

FastAPI is especially important for AI systems because:

• Fast

• Async-ready

• Great for inference APIs

Stage 11 — Learn Deployment & DevOps

This separates hobbyists from real engineers.

You must learn:

• Docker

• Kubernetes

• CI/CD

• GitHub Actions

• Nginx

• Linux basics

Why?

Because production AI systems need:

• Scalability

• Reliability

• Monitoring

• Load balancing

Real AI engineering is infrastructure-heavy.

Stage 12 — Learn Cloud Platforms

Modern AI systems run on cloud infrastructure.

Learn:

• AWS

• Google Cloud

• Azure

Especially:

• GPU instances

• Storage systems

• Serverless inference

• AI deployment pipelines

Because eventually:

Your AI system must serve real users at scale.

Stage 13 — Learn MLOps

MLOps is DevOps for Machine Learning.

It handles:

• Experiment tracking

• Dataset versioning

• Monitoring

• Reproducibility

• Model deployment

Tools:

• MLflow

• Weights & Biases

• DVC

• Kubeflow

Without MLOps:
Production AI becomes chaos.

Stage 14 — Learn System Design for AI

This is the level most people never reach.

At scale, AI engineering becomes:

• Architecture design

• Latency optimization

• GPU efficiency

• Context optimization

• Distributed systems

You’ll need to think about:

• Token cost

• Inference speed

• Caching

• Vector retrieval latency

• Multi-agent coordination

• Streaming architectures

This is where senior AI engineers stand apart.

The Biggest Mistake Beginners Make

They learn tools without understanding layers.

AI engineering is layered like this:

Programming
   ↓
Math & Data
   ↓
Machine Learning
   ↓
Deep Learning
   ↓
Transformers
   ↓
LLMs
   ↓
RAG & Agents
   ↓
Deployment
   ↓
MLOps & Scaling

If the lower layers are weak:

the upper layers collapse.

Final Advice

Do not chase every new framework.

The AI ecosystem changes every few months.

But these remain timeless:

• Programming fundamentals
  

• Mathematics
  

• System thinking
  

• Architecture understanding
  

• Problem-solving ability
  

Frameworks are temporary.

Concepts are permanent.

And the best AI Engineers are not the people who know the most tools.

They are the people who understand:

how intelligence systems are designed end-to-end.

That is the real goal.

Sentence:

“The cat sat on the mat because it was tired.”

When you read “it”
Your brain automatically connects it to “cat”, not “mat”.

That’s attention.

You’re focusing on the right word based on context.

How models use Attention

In models like the Transformer architecture (from the paper Attention Is All You Need):

Every word:

• Look at all other words

• Decides:
  “Which words are important for me?”

Example

Sentence:

“I went to the bank to deposit money.”

Word: bank

Attention helps decide:

• Is it river bank? ❌

• Or financial bank? ✅

It looks at “deposit money” → gives clue

Simple intuition

For each word:

1. Compare with all other words

2. Give importance scores

3. Focus more on important ones

Attention = weighted focus on relevant information

Why it matters

Without attention:

• Model reads everything equally → confused

With attention:

• Model understands context → smarter outputs

PHASE 1: Programming + Math (FREE GOLD)

🔹 Python

• freeCodeCamp (Python full course on YouTube)

• CS50 (best foundation thinking 🔥)

🔹 Math (Intuition-Based)

• 3Blue1Brown
  → Linear Algebra playlist (MUST WATCH)

• Khan Academy
  → Probability + Statistics

🔹 Practice

• LeetCode (easy level enough)

• HackerRank

PHASE 2: Machine Learning (Core Understanding)

🔹 Theory + Practical

• Machine Learning by Andrew Ng
  → Still one of the BEST

• Hands-On Machine Learning with Scikit-Learn, Keras, and TensorFlow (PDF easily available)

🔹 Learn by Doing

• Kaggle
  → Micro-courses + datasets + notebooks

🔹 From Scratch Learning

• YouTube search:

  • “ML algorithms from scratch using NumPy”

PHASE 3: Deep Learning

🔹 Core Courses

• Deep Learning Specialization (audit free)

• fast.ai Practical Deep Learning 🔥 (VERY practical)

🔹 PyTorch (Must)

• Official tutorials of PyTorch

• YouTube:

  • “PyTorch full course freeCodeCamp”

🔹 Transformers (Important 🚀)

• Hugging Face course (FREE + industry standard)

PHASE 4: Project-Based Learning

🔹 Where to Find Projects

• GitHub
  → Search: “AI projects beginner to advanced”

• Krish Naik

• CodeBasics

🔹 Must-Do Project Resources

• Kaggle competitions (real-world problems)

• Build clones:

  • ChatGPT clone

  • Resume analyzer

  • AI drawing (like your project 🔥)

PHASE 5: MLOps + Deployment

🔹 Version Control

• Git + GitHub

  • freeCodeCamp Git course

🔹 Deployment

• FastAPI tutorials (YouTube)

• Docker:

  • “Docker for beginners freeCodeCamp”

🔹 MLOps Learning

• MLflow docs

• DVC

PHASE 6: LLMs, RAG, AI Systems (2026 MOST IMPORTANT)

🔹 LLM Courses

• DeepLearning.AI short courses (FREE 🔥)

• OpenAI docs

🔹 Frameworks

• LangChain docs + YouTube

• LlamaIndex

🔹 RAG Learning

• Search:

  • “RAG from scratch Python tutorial”

• Hugging Face + LangChain tutorials

Phase 1: Linux & Networking

• Linux (Practical): OverTheWire: Bandit – This is a game where you learn Linux by “hacking” into levels using the command line. It’s the most fun way to learn.

• Networking: Cisco Networking Academy (Skills For All) – Look for “Networking Basics.” It’s a professional-grade course for free.

• Scripting: Automate the Boring Stuff with Python – A classic free book/website that focuses on practical automation.

Phase 2: Cloud Core (AWS/GCP)

• AWS: AWS Skill Builder – Use the “Cloud Practitioner Essentials” path. It’s the official training from Amazon.

• Google Cloud: Google Cloud Skills Boost – They often offer a “Free Tier” and specific free quests like “GCP Essentials.”

• Azure: Microsoft Learn – Search for the AZ-900 (Azure Fundamentals) learning path.

Phase 3 & 4: DevOps, Containers & IaC

• Docker & Kubernetes: Play with Docker and Play with Kubernetes – These provide free browser-based labs so you don’t have to install anything on your PC.

• Terraform: HashiCorp Learn – The official tutorials are excellent and cover everything from beginner to advanced.

• Hands-on Labs: KodeKloud Free Courses – They have excellent “Crash Courses” for Docker, Kubernetes, and Linux with interactive labs.

Phase 5 & 6: The Modern Stack & Projects

• GitOps: Introduction to GitOps (EdX/Linux Foundation) – Learn how to manage infrastructure via Git.

• Real-World Projects: The Cloud Resume Challenge – This is a famous community project. While the full guide has a paid version, the “steps” are free to read, and you can build the project yourself by Googling each step.

My Recommendation:

Start with OverTheWire (Bandit) for Linux and AWS Skill Builder for Cloud.

Here’s the real reason DevOps matters now:

1. AI is speeding up coding — but not deployment
Tools can generate code in seconds. But getting that code safely into production? That still requires solid pipelines, infrastructure, monitoring, and reliability. DevOps is the layer AI hasn’t replaced.

2. Systems are getting more complex
Microservices, cloud-native apps, distributed systems — everything is interconnected. Without DevOps practices, things break fast and at scale.

3. Speed = survival for companies
Startups and big tech alike need to ship features faster than ever. DevOps enables rapid, reliable releases instead of slow, risky deployments.

4. High demand, low real expertise
Many people “know tools,” but very few understand systems thinking, automation, and reliability engineering. That gap is where the real opportunities are.

5. It makes you a top-tier engineer
Learning DevOps forces you to understand:

• How the internet works

• How systems scale

• How failures happen

• How to build resilient architecture

That’s what separates average engineers from the top 1%.

DevOps Roadmap (2026) —

Resources to Learn

1. Linux (OS Basics)
Title: Learn Linux (Interactive)
Link: https://www.learn-linux.org/

2. Version Control (Git & GitHub)
Title: Git & GitHub Full Course – Amigoscode
Link: https://www.youtube.com/@amigoscode

3. Cloud (AWS)
Title: AWS Cloud Practitioner Essentials
Link: https://www.aws.training/Details/Curriculum?id=20685

4. Containers (Docker)
Title: Docker Full Course – TechWorld with Nana
Link: https://www.youtube.com/@TechWorldwithNana

5. Orchestration (Kubernetes)
Title: Kubernetes Course (Hinglish) – Kelementry
Link: https://www.youtube.com/@AbhishekVeeramalla

6. CI/CD (Jenkins / GitHub Actions)
Title: CI/CD Pipeline – Train With Shubham
Link: https://www.youtube.com/@TrainWithShubham

7. Infrastructure as Code (Terraform)
Title: Terraform Hands-on Labs
Link: https://developer.hashicorp.com/terraform/tutorials

8. Monitoring (Prometheus & Grafana)
Title: Monitoring Bootcamp – FreeCodeCamp
Link: https://www.youtube.com/@freecodecamp

9. Practice (Hands-on Labs)
Title: DevOps Labs – Killercoda
Link: https://killercoda.com/

10. Cheetsheet

Cheat-Sheets.org: Saare tools (Linux, Docker, Git) ke ek-page ke PDF yahan mil jayenge. Link

Leave a comment

Let’s Connect:

Instagram: https://instagram.com/codingdidi
YouTube: https://youtube.com/@codingdidi

1. Public APIs Hub — https://github.com/public-apis/public-apis
A massive list of free APIs across categories — weather, finance, AI, sports, and crypto.
Perfect starting point to explore what’s even possible.

2. Postman —

https://www.postman.com/

The easiest way to test APIs without writing code.
Send requests, see responses, understand headers, auth, everything visually.
Every beginner should start here.

3. RapidAPI —

https://rapidapi.com/

Discover and connect to thousands of APIs in one place.
Try endpoints instantly, no setup headache. Great for quick projects.

4. JSONPlaceholder —

https://jsonplaceholder.typicode.com/

A fake API for testing and prototyping.
Perfect for beginners to practice CRUD operations without breaking anything.

5. ReqRes —

https://reqres.in/

Simulates real-world API scenarios like login, users, pagination.
Great for understanding how real backend systems behave.

6. Swagger — https://swagger.io/tools/swagger-ui/
Learn how APIs are documented and explored professionally.
If you understand Swagger, you understand real-world APIs.

7. Stripe API — https://stripe.com/docs/api
One of the best real-world APIs to learn from.
Clean docs, real use case (payments), industry standard quality.

8. OpenWeather API — https://openweathermap.org/api
Fetch live weather data and build something useful instantly.
Great first “real project” API.

9. GitHub API — https://docs.github.com/en/rest
Access repositories, users, commits — all via API.
Perfect for dev-focused projects and automation.

10. Twilio API — https://www.twilio.com/docs
Send SMS, OTPs, calls using APIs.
This is where APIs start feeling powerful.

Start with number one.

Then pick one API + one idea and build something small:
weather app, GitHub tracker, SMS notifier — anything.

That’s how you stop “learning APIs”
…and start actually understanding them.

Leave a comment

let’s Connect:

Instagram: https://instagram.com/codingdidi
YouTube: https://youtube.com/@codingdidi

Phase 1: Core Mental Models

Learn Systems + Thinking

• Designing Data-Intensive Applications — MUST READ (even partially)

• Clean Architecture — system design thinking

Practical

• YouTube: Hussein Nasser (systems design)

• Async Python:

  • FastAPI docs

  • asyncio official docs

Phase 2: LLM + Retrieval Mastery

Core Learning

• Hands-On Large Language Models

• Natural Language Processing with Transformers

Concepts (Best Sources)

• Hugging Face Course (FREE, gold)

• DeepLearning.AI LLM courses

Practice

• Build embedding search with FAISS

• OpenAI / open-source APIs

Phase 3: RAG Systems

Guides

• LangChain docs (RAG section)

• LlamaIndex docs (very underrated)

Deep Concepts

• Chunking strategies (blog: Pinecone)

• Retrieval optimization (YouTube + papers)

Must Practice

• Chat with PDF

• Multi-document QA

• Hybrid search

Phase 4: Agent Fundamentals

Learn Core Concepts

• LangGraph docs (BEST for real agents)

• AutoGPT GitHub (study architecture)

Concepts

• ReAct paper

• Tool calling (OpenAI function calling)

Phase 5: Multi-Agent Systems

Tools

• CrewAI (very beginner → advanced friendly)

• LangGraph (production-level)

Learn From

• CrewAI docs + examples

• Real GitHub repos (search “multi-agent system”)

Phase 6: Memory Systems

Learn

• Vector DB concepts (Pinecone blogs)

• Redis docs (for fast memory)

Tools

• FAISS

• Chroma

• Redis

Practice

• Build long-term memory chatbot

• Add conversation recall

Phase 7: Tool Use & Integration

Learn

• OpenAI function calling

• JSON schema outputs

Tools

• FastAPI

• Postman

• Zapier / APIs

Practice

• Gmail automation agent

• Web scraping agent

Phase 8: Planning & Reasoning

Must Read Papers

• ReAct (Google)

• Tree of Thoughts

Learn From

• DeepLearning.AI short courses

• YouTube: AssemblyAI, AI Explained

Leave a comment

Let’s Connect

Instagram: https://instagram.com/codingdidi
YouTube: https://youtube.com/@codingdidi

Few understand it.

The “AI air drawing” project looks magical.
You move your finger.
A line appears in the air.

It feels like intelligence.

It’s mostly math.

What’s Actually Happening

Strip away the hype.

This system has only three parts:

Camera → Hand Detection → Drawing

That’s it.

No mystery.
Just transformations.

Step 1: Your Camera Is Just a Matrix

Every frame from your webcam
is a grid of numbers.

An image is not “visual” to a computer.

It’s a matrix:

Width × Height × Channels

Each pixel = (R, G, B)

So when you move your hand,
you’re just changing numbers in this grid.

Step 2: Hand Tracking Is Coordinate Prediction

This is where MediaPipe comes in.

It doesn’t “see a hand” like you do.

It predicts keypoints.

21 points per hand.

Each point has:
x, y, z

Where:
x → horizontal position
y → vertical position
z → depth (relative)

The Math Behind It (Simplified)

Under the hood, MediaPipe uses deep learning.

A trained neural network learns a function:

Image → Landmark Coordinates

You can think of it as:

f(image) = [(x₁, y₁, z₁), … (x₂₁, y₂₁, z₂₁)]

This is regression.

Not classification.

It’s not saying “this is a hand”.
It’s saying:

“These are the exact points of the hand.”

What is hand_landmarker.task?

This file confuses a lot of people.

It’s not just a model.

It’s a packaged pipeline.

Inside it:

– A trained ML model (TensorFlow Lite)
– Preprocessing steps
– Postprocessing logic
– Metadata for inference

Think of it as:

“Everything needed to go from image → landmarks”

in one file.

That’s why you don’t write the ML code yourself.

You just load it.

Step 3: Normalized Coordinates

MediaPipe does something important.

It gives coordinates between 0 and 1.

Not pixels.

So:
(0,0) → top-left
(1,1) → bottom-right

Why?

Because it makes the system resolution-independent.

Converting to Screen Space

But you need pixel positions to draw.

So you convert:

x_pixel = x_normalized × image_width
y_pixel = y_normalized × image_height

That’s it.

Simple scaling.

But this step is everything.

This is where math meets visuals.

Step 4: Drawing = Connecting Points Over Time

Now comes the illusion.

You’re not drawing in the air.

You’re tracking motion.

Each frame gives a new point.

You store previous positions.

Then draw a line:

Line(previous_point, current_point)

Repeat this 30 times per second.

Now it looks continuous.

That’s your “air canvas”.

Why It Feels Like Magic

Because your brain fills gaps.

Discrete points → perceived motion

This is the same principle as video itself.

Frames.
Sequence.
Continuity illusion.

Step 5: Why One Finger Works

You usually track the index finger tip.

In MediaPipe, that’s landmark 8.

Why?

Because it’s stable.
And intuitive.

So your logic becomes:

Track landmark 8 → convert → draw

Minimal code.

Clear system.

The Real Learning Most People Miss

Most tutorials stop at:

“Here’s the code.”

But code is the surface.

The real system is:

Detection → Transformation → Rendering

If you understand this,
you can rebuild it anywhere.

Different language.
Different library.

Same logic.

Three Things That Actually Matter

Understanding coordinate systems

Knowing what the model outputs

Separating logic from tools

Where People Go Wrong

They trust the library too much.

They don’t question outputs.

They don’t visualize the pipeline.

So when something breaks,
they’re stuck.

Proof This Matters

Try this:

Remove MediaPipe.

Can you still explain the system?

If not,
you were using it, not learning it.

The Bigger Picture

This small project teaches:

Computer vision basics
Real-time systems
Human-computer interaction

That’s not small.

That’s foundational.

Final Thought

You don’t need more complex projects.

You need deeper understanding.

Same code.
Different mindset.

That’s the real upgrade.

Code reference: link

YouTube explanation: link

Paper Link: https://arxiv.org/abs/2207.10062

5 Key Takeaways:

• Focus shifts from model-centric → data-centric AI (quality of data matters more than model tweaks).

• Introduces benchmarks to evaluate data improvement techniques, not just models.

• Highlights importance of data cleaning, labeling, and augmentation.

• Encourages systematic ways to measure how data changes affect performance.

• Opens a new research direction: optimizing datasets instead of architectures.

2. Language Models are Few-Shot Learners (GPT-3)

Paper Link: https://arxiv.org/abs/2005.14165

5 Key Takeaways:

• Large language models can perform tasks with very few examples (few-shot learning).

• Scaling model size drastically improves performance across tasks.

• No need for task-specific fine-tuning in many cases.

• Demonstrates strong performance in NLP tasks like translation, QA, and summarization.

• Shows limitations: bias, hallucination, and high compute cost.

3. FlashAttention: Fast and Memory-Efficient Attention

Paper Link: https://arxiv.org/abs/2205.14135

5 Key Takeaways:

• Reduces memory usage of attention using IO-aware algorithm design.

• Enables training on longer sequences efficiently.

• Maintains exact attention (not approximation) but faster execution.

• Improves GPU utilization and reduces memory bottlenecks.

• Crucial for scaling transformers in real-world applications.

4. Training Neural Networks with Posits (PositNN)

Paper Link: https://arxiv.org/abs/2101.09160

5 Key Takeaways:

• Introduces posit number system as an alternative to floating-point.

• Achieves similar or better accuracy with lower precision.

• Improves energy efficiency and hardware performance.

• Useful for edge devices and low-resource environments.

• Suggests new direction for efficient AI hardware design.

5. AdderNet: Do We Really Need Multiplications in Deep Learning?

Paper Link: https://arxiv.org/abs/1912.13200

5 Key Takeaways:

• Replaces multiplications with additions in neural networks.

• Reduces computational cost and energy consumption.

• Maintains competitive accuracy on vision tasks.

• Inspired by biological neurons (less reliance on multiplication).

• Promising for low-power AI systems and hardware acceleration.