- Creating virtual envs. using uv is ~80x faster than python -m venv.
- Package installation is 4–12x faster without caching, and ~100x with caching
Today, let's understand how to use uv for Python package management.
Let's dive in!
uv is a Rust-based Python package manager built to be fast and reliable.
It replaces not just pip but also pip-tools, virtualenv, pipx, poetry, and pyenv, all with a single standalone binary.
Here's a uv cheatsheet for Python devs👇
Let's look at the code next!
1️⃣ Create a new project
To set up a new Python project, run: uv init project-name.
This creates a directory structure, a TOML file, a sample script, and a README.
Check this 👇
2️⃣ Initialize an env.
Although uv automatically initializes a virtual env. in a project, you can explicitly create a virtual env. with `uv venv` command.
Activate it as follows:
- MacOS/Linux: source .venv/bin/activate
- Windows: .venv\Scripts\activate
Check this 👇
3️⃣ Install packages
Next, you can add dependencies using `uv add <library-name>` command.
When you add packages, uv updates the toml file and resolves the full dependency tree, generating a lockfile.
Check this 👇
4️⃣ Execute a script
To run a script, use `uv run script[.]py` command.
If a package is not available in your environment but it is used in the script, uv will install it when you run the script, provided the dependency is specified in the toml file.
Check this 👇
5️⃣ Reproduce an env.
Finally, uv gives 100% reproducible installs.
Say you cloned a project that used uv. You can run `uv sync` to precisely match the project.
This works across OS, and even if the project you cloned used a different Python version.
Check this 👇
And that is how you can start using uv.
Note: When you push your project to GitHub, DO NOT add the uv[.]lock file to your gitignore file. This helps uv reproduce the environment when others use your project.
Here is the cheatsheet again for your reference 👇
If you found it insightful, reshare with your network.
Find me → @akshay_pachaar ✔️
For more insights and tutorials on LLMs, AI Agents, and Machine Learning!
dLLM is a Python library that unifies the training & evaluation of diffusion language models.
You can also use it to turn ANY autoregressive LM into a diffusion LM with minimal compute.
100% open-source.
Here's why this matters:
Traditional autoregressive models generate text left-to-right, one token at a time. Diffusion models work differently - they refine the entire sequence iteratively, giving you better control over generation quality and more flexible editing capabilities.
You're in a Research Scientist interview at Google.
Interviewer: We have a base LLM that's terrible at maths. How would you turn it into a maths & reasoning powerhouse?
You: I'll get some problems labeled and fine-tune the model.
Interview over.
Here's what you missed:
When outputs are verifiable, labels become optional.
Maths, code, and logic can be automatically checked and validated.
Let's use this fact to build a reasoning model without manual labelling.
We'll use:
- @UnslothAI for parameter-efficient finetuning.
- @HuggingFace TRL to apply GRPO.
Let's go! 🚀
What is GRPO?
Group Relative Policy Optimization is a reinforcement learning method that fine-tunes LLMs for math and reasoning tasks using deterministic reward functions, eliminating the need for labeled data.
Here's a brief overview of GRPO before we jump into code:
NOBODY wants to send their data to Google or OpenAI.
Yet here we are, shipping proprietary code, customer information, and sensitive business logic to closed-source APIs we don't control.
While everyone's chasing the latest closed-source releases, open-source models are quietly becoming the practical choice for many production systems.
Here's what everyone is missing:
Open-source models are catching up fast, and they bring something the big labs can't: privacy, speed, and control.
I built a playground to test this myself. Used CometML's Opik to evaluate models on real code generation tasks - testing correctness, readability, and best practices against actual GitHub repos.
Here's what surprised me:
OSS models like MiniMax-M2, Kimi k2 performed on par with the likes of Gemini 3 and Claude Sonnet 4.5 on most tasks.
But practically MiniMax-M2 turns out to be a winner as it's twice as fast and 12x cheaper when you compare it to models like Sonnet 4.5.
Well, this isn't just about saving money.
When your model is smaller and faster, you can deploy it in places closed-source APIs can't reach:
↳ Real-time applications that need sub-second responses
↳ Edge devices where latency kills user experience
↳ On-premise systems where data never leaves your infrastructure
MiniMax-M2 runs with only 10B activated parameters. That efficiency means lower latency, higher throughput, and the ability to handle interactive agents without breaking the bank.
The intelligence-to-cost ratio here changes what's possible.
You're not choosing between quality and affordability anymore. You're not sacrificing privacy for performance. The gap is closing, and in many cases, it's already closed.
If you're building anything that needs to be fast, private, or deployed at scale, it's worth taking a look at what's now available.
MiniMax-M2 is 100% open-source, free for developers right now. I have shared the link to their GitHub repo in the next tweet.
You will also find the code for the playground and evaluations I've done.
Claude Skills might be the biggest upgrade to AI agents so far!
Some say it's even bigger than MCP.
I've been testing skills for the past 3-4 days, and they're solving a problem most people don't talk about: agents just keep forgetting everything.
In this video, I'll share everything I've learned so far.
It covers:
> The core idea (skills as SOPs for agents)
> Anatomy of a skill
> Skills vs. MCP vs. Projects vs. Subagents
> Building your own skill
> Hands-on example
Skills are the early signs of continual learning, and they can change how we work with agents forever!
Here's everything you need to know:
Skills vs. Projects vs. Subagents:
If you found it insightful, reshare with your network.
Find me → @akshay_pachaar ✔️
For more insights and tutorials on LLMs, AI Agents, and Machine Learning!