Awesome Artificial Intelligence

An opinionated, actively maintained collection of resources for software developers learning to build and ship generative AI and agentic systems.

This list is for developers who want to:

• understand the foundations behind modern AI systems;
• build applications with language models, retrieval, tools, and agents;
• evaluate, observe, and deploy AI systems in production;
• use coding agents to improve software engineering work.

This is not a comprehensive directory of AI products. Every entry must clear an absolute quality bar for technical depth, practical value, evidence, and distinctiveness. Categories are not quotas, and a short category is better than one padded with weak choices.

The list is reviewed weekly by an evidence-backed automation that proposes small changes for human review. See how resources are evaluated.

Learn

Books

• Artificial Intelligence: A Modern Approach: The broad reference for classical AI, including search, reasoning, planning, learning, and robotics.
• Reinforcement Learning: An Introduction: Sutton and Barto's foundational treatment of reinforcement learning concepts and algorithms.
• Designing Machine Learning Systems: Scalable, maintainable machine learning systems by Chip Huyen.
• AI Engineering: Building applications with foundation models by Chip Huyen.
• Build a Large Language Model from Scratch: Implement transformers in PyTorch with Sebastian Raschka.
• Hands-On Large Language Models: A visual and practical guide by Jay Alammar and Maarten Grootendorst.
• LLM Engineer's Handbook: LLMOps, fine-tuning, serving, and production workflows.
• The 100-Page Language Models Book: A concise, technical introduction by Andriy Burkov.
• Deep Learning: Mathematical foundations by Ian Goodfellow, Yoshua Bengio, and Aaron Courville.
• Deep Learning: Foundations and Concepts: A probability-grounded treatment by Christopher and Hugh Bishop.
• Understanding Deep Learning: Theory, intuition, and practical notebooks by Simon Prince.
• Speech and Language Processing: The continuously updated NLP reference by Dan Jurafsky and James Martin.

Courses

• Hugging Face LLM Course: Transformers, fine-tuning, datasets, and modern NLP tooling.
• Full Stack Deep Learning: The full lifecycle of building and shipping AI products.
• Fast.ai Practical Deep Learning: A code-first introduction to deep learning.
• Karpathy's Neural Networks: Zero to Hero: Build neural networks and language models from first principles.
• Stanford CS336: Language Modeling from Scratch: Build language models from data preparation through evaluation and deployment.
• MIT 6.S191: Introduction to Deep Learning: Deep learning foundations and applications.
• Google Generative AI Learning Path: An introductory path through generative AI concepts and Google Cloud tooling.
• DeepLearning.AI Short Courses: Focused courses on current generative AI engineering techniques.
• Made With ML: An open course on designing, developing, deploying, and iterating on production ML systems.

Foundational papers

• Attention Is All You Need: Introduced the Transformer architecture.
• Scaling Laws for Neural Language Models: Explored relationships between model performance, data, and compute.
• Training Compute-Optimal Large Language Models: Showed how model size and training data should scale together under a compute budget.
• Language Models are Few-Shot Learners: Demonstrated in-context learning at scale.
• Retrieval-Augmented Generation: Combined parametric language models with external retrieval for knowledge-intensive tasks.
• LoRA: Introduced low-rank adaptation for parameter-efficient model fine-tuning.
• Training Language Models to Follow Instructions with Human Feedback: Established the instruction tuning and RLHF recipe used by InstructGPT.
• ReAct: Combined reasoning traces with actions for tool-using language-model agents.
• Constitutional AI: A method for training helpful and harmless AI assistants using written principles.
• Direct Preference Optimization: Reframed preference alignment as a simple classification objective without explicit reward modelling.

Build AI systems

Guides and playbooks

• Building Effective Agents: Anthropic's practical patterns and tradeoffs for agentic systems.
• A Practical Guide to Building Agents: OpenAI's guide to models, tools, instructions, orchestration, and guardrails.

LLM application engineering

• OpenAI Cookbook: Code examples for structured outputs, tool use, retrieval, evals, and other LLM application patterns.
• Anthropic Prompt Engineering: Techniques for defining success criteria, testing prompts, and improving model behaviour.
• Effective Context Engineering for AI Agents: How to select, structure, and manage the context available to long-running agents.
• 12-Factor Agents: Practical principles for building controllable LLM applications around deterministic software.
• OWASP Top 10 for LLM Applications: Risks and mitigations for developing and deploying generative AI applications.

Agent frameworks

• Pydantic AI: Typed agent development built around Pydantic.
• LangGraph: Low-level orchestration for long-running, stateful agents.
• OpenAI Agents SDK: A small SDK for tools, handoffs, guardrails, tracing, and agent orchestration.
• Google Agent Development Kit: Google's framework for developing and evaluating agents.
• Microsoft Agent Framework: Microsoft's successor to AutoGen and Semantic Kernel for agents and graph-based workflows.

Durable and asynchronous agents

• Effective Harnesses for Long-Running Agents: Patterns for agents that make progress across multiple context windows and recover from failure.
• Running Agents: Lifecycle, session, exception, and durable-execution patterns in the OpenAI Agents SDK.
• Human-in-the-Loop: Pause, inspect, approve, reject, and resume tool calls without losing agent state.
• Gemini and Temporal Durable Agent: A concrete implementation of durable execution, retries, and human approval for an agent workflow.

Retrieval and data

• LlamaIndex: Data ingestion, indexing, retrieval, and agent workflows.
• Haystack: Modular pipelines for retrieval and generative AI applications.
• Docling: Document parsing and conversion for AI applications.

Evals and reliability

• Demystifying Evals for AI Agents: A practical method for building task suites, graders, transcripts, and evaluation harnesses.
• OpenAI Evals: An open-source framework and registry for evaluating language models and systems.
• Promptfoo: Test cases, assertions, model comparisons, and red-team checks for LLM applications.
• Ragas: Evaluation and experimentation for retrieval and generative AI applications.

Deployment and observability

• Langfuse: Tracing, evaluation, prompt management, and metrics for LLM applications.
• vLLM: An inference and serving engine for language models.
• LiteLLM: A model gateway and unified interface for multiple model providers.

Agentic software engineering

Coding agents help developers plan, implement, review, test, and debug software. For independent capability comparisons, see SWE-bench and Terminal-Bench.

Coding agents

• Claude Code: A terminal agent with hooks, subagents, skills, and repository-level instructions.
• Codex CLI: An open-source terminal agent with sandbox and approval controls.
• Gemini CLI: An open-source terminal agent built around Gemini and extensible tools.
• Cursor CLI: A terminal agent connected to Cursor's editor and cloud workflows.
• GitHub Copilot coding agent: An asynchronous agent that works from GitHub issues and opens pull requests.
• Aider: An open-source pair programmer with Git integration and broad model support.
• OpenCode: An open-source, provider-independent terminal agent with a client-server architecture.
• OpenHands: An open-source platform for running software development agents locally or in the cloud.
• Cline: An open-source coding agent available as an editor extension, CLI, and SDK.
• Continue: Open-source coding agents for IDE and CI workflows with source-controlled configuration.

Software factories and agent orchestration

• Harness Engineering: OpenAI's field report on building software with coding agents, repository constraints, automated checks, and human steering.
• Codex Orchestration with Symphony: A reference architecture that turns project work into isolated, observable coding-agent runs.
• How We Built Our Multi-Agent Research System: Production lessons on orchestrator-worker agents, parallel search, evaluation, and operational reliability.

Contributing

Suggestions are welcome, but this list is intentionally selective. Read the curation policy before opening an issue or pull request.

A proposed resource should:

• serve software developers learning or practising AI engineering;
• provide technical or practical value beyond a product homepage;
• be current and maintained, unless its value is foundational and durable;
• add something meaningfully different from the existing entries;
• use a factual description supported by a primary source.

Explain which developer problem the resource solves and why it clears the rubric. If it overlaps an existing entry, explain why it is materially better. Disclose any affiliation with the resource.