AI-native studio. We ship production AI tools & open-source software — Production AI, and keep it running.
online
Joined October 2016
- Tweets18.3K
- Following176
- Followers4.9K
- Likes16.9K
Pinned Tweet
Fully reproducible benchmark: facts file, runner, grader, every raw reply published. Both conditions cost $0.71 on Ollama Cloud.
The knowledge layer is open source, local-first, an MCP server — 61 verified platform packs injected on every optimize call.
npm i clarifyprompt-mcp
Report: github.com/LumabyteCo/clarif… Repo: github.com/LumabyteCo/clarif…
LumaByte retweeted
10 System Prompt Design & Role-Setting Concepts Every Agent-Personality Engineer Should Master
Building AI agents is more than connecting an LLM to tools.
You must define how your agent thinks, behaves, communicates, and makes decisions.
Master these 10 concepts:
→ 1. Clear Role Definition — Define the agent’s identity, expertise, responsibilities, and boundaries.
→ 2. Goal & Objective Setting — Specify what the agent must achieve and how success is measured.
→ 3. Context & Constraints — Provide relevant background, limitations, and rules the agent must follow.
→ 4. Instructions & Behavior Rules — Define workflows, priorities, and how the agent handles missing information.
→ 5. Persona & Communication Style — Control tone, personality, language, and response style.
→ 6. Few-Shot Prompting — Use input-output examples to demonstrate the exact behavior you expect.
→ 7. Output Format & Structure — Enforce consistent responses using Markdown, JSON, schemas, or templates.
→ 8. Tool Usage & Action Guidelines — Define when to call tools, which tools to use, and how to handle results.
→ 9. Safety, Ethics & Guardrails — Prevent unsafe actions, protect sensitive information, and reduce harmful outputs.
→ 10. Iteration & Evaluation — Test prompts, measure performance, identify failures, and refine instructions continuously.
The winning formula:
Role → Goals → Context → Instructions → Persona → Examples → Output → Tools → Safety → Evaluation
Remember: A powerful LLM does not automatically make a reliable agent.
Well-designed system prompts turn raw model capabilities into consistent, goal-driven agent behavior.
Save this roadmap. Build better agents.
Follow @e_opore for more AI agent engineering insights.
Grab Building an Agent from Scratch Course EBOOK : codewithdhanian.gumroad.com/…
LumaByte retweeted
You type “What is gravity?” into ChatGPT, Claude or Gemini, and an answer starts showing up in under a second.
I animated everything that happens in between, step by step.
𝟭. 𝗬𝗼𝘂𝗿 𝘁𝗲𝘅𝘁 𝗴𝗲𝘁𝘀 𝗰𝘂𝘁 𝗶𝗻𝘁𝗼 𝘁𝗼𝗸𝗲𝗻𝘀
The model can’t read words. A tokenizer splits your question into small pieces, so “gravity” might become “grav” and “ity”. Each piece gets an ID number.
𝟮. 𝗧𝗼𝗸𝗲𝗻𝘀 𝗯𝗲𝗰𝗼𝗺𝗲 𝗹𝗶𝘀𝘁𝘀 𝗼𝗳 𝗻𝘂𝗺𝗯𝗲𝗿𝘀
Each ID is swapped for a long list of numbers that captures its meaning. In Llama 3 8B that list is 4,096 numbers long.
𝟯. 𝗧𝗵𝗲 𝘁𝗼𝗸𝗲𝗻𝘀 𝗹𝗼𝗼𝗸 𝗮𝘁 𝗲𝗮𝗰𝗵 𝗼𝘁𝗵𝗲𝗿
This is attention. Each token checks the tokens before it and pulls in what’s relevant. “ity” looks back at “grav” and works out the word is gravity. The model repeats this through a stack of layers, 32 of them in Llama 3 8B.
𝟰. 𝗘𝘃𝗲𝗿𝘆 𝗽𝗼𝘀𝘀𝗶𝗯𝗹𝗲 𝗻𝗲𝘅𝘁 𝘄𝗼𝗿𝗱 𝗴𝗲𝘁𝘀 𝗮 𝘀𝗰𝗼𝗿𝗲
The model scores all of the roughly 128,000 tokens it knows and turns those scores into probabilities.
𝟱. 𝗢𝗻𝗲 𝘁𝗼𝗸𝗲𝗻 𝗶𝘀 𝗽𝗶𝗰𝗸𝗲𝗱
Greedy takes the top choice. Top K and Top P pick from a short list of strong candidates. Temperature decides how much risk the pick takes. Turn it down for factual answers and up for brainstorming.
𝟲. 𝗜𝘁 𝗿𝗲𝗽𝗲𝗮𝘁𝘀 𝗳𝗼𝗿 𝘁𝗵𝗲 𝗻𝗲𝘅𝘁 𝘁𝗼𝗸𝗲𝗻
The picked token is added to the text and the process runs again. “Gravity”, then “is”, then “a”, then “fundamental”. You see each token the moment it’s made, so answers show up word by word.
𝗧𝗵𝗲 𝘀𝗽𝗲𝗲𝗱 𝘁𝗿𝗶𝗰𝗸𝘀
𝗞𝗩 𝗰𝗮𝗰𝗵𝗲: the model saves its notes on earlier tokens so it doesn’t redo that work for every new word. Those notes grow with every token, so long chats use a lot of GPU memory.
𝗦𝗽𝗲𝗰𝘂𝗹𝗮𝘁𝗶𝘃𝗲 𝗱𝗲𝗰𝗼𝗱𝗶𝗻𝗴: a small model guesses the next few words and the big model checks them all in one pass, keeping every guess up to the first one it disagrees with.
𝗤𝘂𝗮𝗻𝘁𝗶𝘇𝗮𝘁𝗶𝗼𝗻: the model’s numbers are stored with fewer bits, which cuts memory 2 to 4x.
𝗙𝗹𝗮𝘀𝗵𝗔𝘁𝘁𝗲𝗻𝘁𝗶𝗼𝗻: the attention math is done in small chunks so the GPU makes fewer trips to its slower memory.
Your whole prompt is processed in one parallel pass, while the answer has to be written one token at a time. So the length of the answer drives the wait far more than the length of your question.
Which of these steps do you think will look completely different two years from now?
GitHub's star-history rebuild carries a lesson that reaches far beyond stars. In their words: returning less data didn't actually make the query any cheaper.
Tools rebuilt a repository's star curve by paging through every stargazer, 100 people per page. For react/react, with about 251,000 stars, that took about 2,511 requests. A pagination bug made each one worse: every request counted all of the repository's stars just to work out how many pages existed.
The new endpoint returns up to 30 weeks of daily star counts per request, with no identities attached, and filters by date before it counts anything. react/react's full history now takes about 24 requests.
What broke on the way there: stargazer and watcher lists are now limited to repository admins and collaborators, so a star-history tool without that access can get an empty response or a 403.
github.blog/engineering/arch…
LumaByte retweeted
العربية من بين ٢٤ لغة تدعمها ميزات Galaxy AI في هواتف سامسونج، ومنها الترجمة الفورية للمكالمات.
أما المساعد الصوتي Bixby فلغاته ١٢، وليست العربية بينها.
وتنبّه سامسونج إلى أن بعض اللكنات واللهجات قد لا تُفهم.
هل جرّبت ترجمة مكالمة بالعربية؟
news.samsung.com/global/sams…
OpenAI will remove GPT-4o, GPT-4o mini, GPT-4.1 and GPT-4.1 mini from its API on 14 January 2027. Developers were told on 14 October, which leaves about 92 days.
The snapshots on the list:
• gpt-4o-2024-08-06 and gpt-4o-2024-11-20
• gpt-4o-mini-2024-07-18
• gpt-4.1-2025-04-14
• gpt-4.1-mini-2025-04-14
OpenAI's recommended replacement for all four is gpt-6-luna.
Easy to miss: fine-tuned versions follow the same shutdown schedule as their base models. A fine-tune built on GPT-4o mini stops working on the same day, so retraining it on the new model and re-running your evals both have to fit inside that window.
developers.openai.com/api/do…
LumaByte retweeted
If you learn distributed systems, you will never be unemployed again.
Stage 1: How requests travel
- Learn: DNS, TCP, TLS, load balancers, latency numbers, threads vs processes.
- Practice: build an HTTP server and load test it until it breaks.
Stage 2: Data
- Learn: indexes, transactions, isolation levels, replication, sharding.
- Practice: shard a Postgres table by user_id and write the rebalancing script.
Stage 3: Async
- Learn: queues, Kafka partitions, consumer groups, at-least-once delivery, idempotency.
- Practice: an order pipeline that survives a consumer crash mid-message.
Stage 4: Failure
- Learn: timeouts, retries with jitter, circuit breakers, backpressure.
- Practice: kill random services in your project and make it recover on its own.
Stage 5: Consistency
- Learn: CAP, quorums, Raft, clocks.
- Practice: build a 3-node key-value store with leader election.
Frameworks change every 3 years. These haven't changed in 30.
LumaByte retweeted
Use this Super Simple Template to Learn How to Implement CI/CD in Your Agile Team.
Often, I see confusion surrounding the integration of Agile Development with a CI/CD pipeline.
To clear the fog, I've put together a straightforward, step-by-step guide that encapsulates the entire process in one easy-to-understand format.
Remember, this isn't merely a CI/CD workflow, but an agile development process harmoniously intertwined with CI/CD flow.
Also, bear in mind that this is just a baseline diagram and the tools/technology used here are examples - feel free to replace them with equivalent tools or technology that suits your team's preferences and requirements.
👉 Let the Product Owner kick-off by crafting engaging user stories.
👉 Have your development team spring into action, bringing these stories to life with tools like Jira/Rally.
Utilize Slack/Team, GitHub/Bitbucket/ Integration to:
• Promote transparency and collaboration.
• Enable continuous integration.
• Catch bugs early.
• Support frequent releases and continuous testing.
Harness the power of SonarQube and DevOps to:
• Conduct static code analysis.
• Trigger builds.
• Provide insightful feedback.
Implement Unit Tests and Code Coverage with JaCoCo and JUnit:
• Use Jenkins and Maven for build and deployment.
• Strive for 100% unit test execution success.
• Maintain at least 80% code coverage.
• Eliminate critical defects/vulnerabilities.
Master Testing and Quality Assurance by:
• Using Selenium for regression and UAT tests.
• Relying on Nexus/Artifactory for Binary Repo.
Enhance Security and Infrastructure Management:
Conduct routine security scans with Qualys.
Employ Terraform and Ansible for infrastructure management.
If you're looking for ways to improve your software development process, CI/CD is definitely worth considering.
Here are some additional tips for implementing CI/CD:
Start small. Don't try to implement CI/CD for your entire codebase all at once.
Start with a small project and then gradually expand your CI/CD pipeline as your needs grow.
Get buy-in from your team. CI/CD can be a big change for your team, so it's important to get buy-in from everyone involved.
Make sure that your team understands the benefits of CI/CD and is willing to put in the effort to make it work.
Automate as much as possible. The more you can automate, the more efficient your CI/CD pipeline will be. Look for opportunities to automate manual tasks, such as building, testing, and deploying code.
Strive to reach these key milestones of automation:
🧪 Unit Test Execution Automation
🛠️ Build Automation
📈 Code Coverage Check Automation
📊 Code Quality Check Automation
🔒 Security Scanning Automation
🚀 Automated Deployments with Gating
💬 Feedback Automation to Production Teams
💾 Binary Storage Automation into Repo Manager
🏗️ Infrastructure Setup Automation
Stay connected for more insights!
Follow me @LearnWithBrij
#DevOps #Agile #softwareengineering
LumaByte retweeted
Diffusion language models are easier to understand if you forget the word diffusion for a minute.
An autoregressive model generates text one token at a time. Each new token is produced after the previous ones are already there.
A masked diffusion model can work differently. It can begin with many unresolved positions and predict all of them in the same pass, then commit only some of those predictions. During training, it sees sequences with different amounts of masking and learns to recover hidden tokens from visible context on both sides. During generation, that process is repeated until the sequence is complete.
In a confidence-based sampler, the model keeps its highest-confidence predictions first and leaves uncertain positions masked for another pass.
That gives diffusion more parallelism, but it also creates a dependency problem.
Suppose four positions are resolved in the same pass. All four predictions were made from the same previous version of the sequence. They cannot use one another as newly available context until the next pass. If those choices depend strongly on each other, quality can suffer.
This is why denoising steps and decoding order matter. Resolve more positions at once and you need fewer sequential passes. Resolve fewer positions and later predictions get more completed context, but inference takes more work.
I think calling this simply “faster text generation” misses the more useful question:
How much of the output can actually be worked on in parallel?
@Cometml tested this with Mercury 2 and Claude Haiku 4.5 on 30 coding tasks, averaged across 20 runs. Mercury averaged about 3.0 seconds end to end versus 6.0 seconds for Haiku, but the overall pass rates were 84% and 99.7%. On the hard tasks, Mercury was at 60% and Haiku at 99%.
Increasing Mercury’s reasoning_effort to high raised its hard-task pass rate to 83%, while latency increased to roughly 7.1 seconds. Inception does not document what that setting changes internally, so I would not treat it as a direct denoising-step control.
I would not use those numbers to claim diffusion is twice as fast as autoregressive generation. These are different models from different providers, and the timings include network and serving overhead.
The useful part is the tradeoff.
If parts of the output can be resolved with weak dependencies between them, there is parallelism to exploit. If unresolved positions depend strongly on one another, more refinement starts to look less like overhead and more like necessary work.
If I were evaluating a diffusion LM for a real system, that is where I would start => not with "is diffusion faster?", but with how much parallelism the workload actually allows.
LumaByte retweeted
SolidCraft is a new open-source CAD app written in pure Rust (MIT or Apache-2.0), with a built-in MCP server so a coding agent such as Claude Code can model parts in it.
Its README reports that 75 of 76 public reference parts match their expected volume, area and centre of mass, and calls the app early but usable for simple parts.
Would you use a part an AI agent modelled without opening it yourself first?
github.com/bherbruck/solidcr…
Vercel Pro teams: deployments older than 30 days start being deleted on 23 October, unless you opt out in your retention settings before then.
The part to check is rollback. Vercel says deleted deployments cannot be used for rollback, so if your recovery plan assumes you can go back further than 30 days, it changes next week.
Retention settings already at 30 days or shorter are unchanged. The same change starts Deployment Storage and Functions Storage billing for all Pro teams at $0.10 per GB-month, and Vercel is emailing each team its start date.
How far back has your team ever actually rolled back?
vercel.com/changelog/deploym…
LumaByte retweeted
Your coding agent probably doesn't need a bigger context window. It needs a cleaner one.
In September 2025, Anthropic called it likely that, for the foreseeable future, context windows of all sizes will be subject to context pollution, at least when you want the strongest agent performance. Most of its Claude Code best practices rest on one constraint: the window fills up fast, and performance degrades as it fills.
One long session:
Task A → "investigate X" → back to A → correction ×2 → same-session review
Where it breaks:
• "investigate X", unscoped: Claude reads hundreds of files, filling the context
• correction ×2: the context is cluttered with failed approaches
• same-session review: Claude reviews code it just wrote
• the whole session: as the window fills, Claude may start "forgetting" earlier instructions
What fixes it in Claude Code:
1. Send the investigation to a subagent. Subagents run in separate context windows and report back summaries.
2. After two failed corrections, /clear and write a better prompt with what you learned. A clean session with a better prompt almost always outperforms a long session with accumulated corrections.
3. Review in a fresh context, where Claude won't be biased toward code it just wrote.
Same session, fixed:
Task A → subagent investigates X → back to A → correction ×2 → /clear + better prompt → fresh-context review
Not just Claude: Chroma's Context Rot report (July 2025) tested 18 models, closed and open-weights, and found performance degrades as input length increases. Open-source Aider (Apache 2.0) has the same moves: /drop files "that don't need any more changes", and when it gets stuck, /clear "to discard the chat history and make a fresh start".
Long sessions are fine when you're deep in one complex problem and the history is valuable.
Which do you use least: a subagent, /clear or a fresh-context review?
code.claude.com/docs/en/best…
anthropic.com/engineering/ef…
aider.chat/docs/usage/tips.h…
#ClaudeCode
Row-level security switched on in Postgres, and the table owner still saw every row.
Now-Next measured row-level security for multi-tenant SaaS on PostgreSQL 17 and published the numbers today. Four results worth checking against your own setup:
1. Without FORCE ROW LEVEL SECURITY, the role that owns the table ignores the policy. In their test it saw 2 of 2 rows whatever the policy said.
2. The policy itself costs almost nothing in its simplest form: 11.0 ms against 11.0 ms to count 267,023 invoices.
3. A helper function in the policy is where it gets expensive. A PL/pgSQL function left VOLATILE took 1,860 to 1,920 ms on every query. Declared STABLE, or wrapped in (select …), it took 0.29 to 0.30 ms.
4. The tenant can leak through PgBouncer. In transaction mode, setting it with SET let the next client, which set no tenant of its own, count the largest tenant's 267,023 invoices. With SET LOCAL inside an explicit transaction it counted 0 rows.
Their own caveats: the timings come from one machine and are meant as proportions, and row-level security is not a complete answer, because foreign keys and unique constraints are checked without the policy.
now-next.nl/en/insights/post…
LumaByte retweeted
Meta released Muse Wonder on Monday, and for developers the practical news is how easily existing code can point at it.
Meta's Model API accepts an OpenAI-SDK-compatible client, and the model is also on OpenRouter. It has a 1M-token context window, reads text, images, video and audio, and replies in text.
Pricing is $4 per million input tokens, $0.20 per million cached input tokens and $20 per million output tokens.
The bigger Muse Wonder Full isn't on the API at all. You get it only through Muse Code, Meta's multi-agent coding tool for the terminal, on the $50 and $200 a month plans.
Meta pitches both for agent tasks that run for hours, and if you wire one up to act on real systems, the model card itself asks for extra guardrails, like a human confirming anything irreversible. Sensible.
Read the launch benchmarks as Meta's own: its notes say the rival models were run best-effort, not tuned for them. Independent numbers are worth waiting for before you switch anything.
Would you test it through OpenRouter first, or wait for those numbers?
research.meta.ai/blog/muse-w…
Google retired two Gemini Flash models on 8 October, and calls to them keep working.
Requests to gemini-3.7-flash are now automatically routed to gemini-3.8-flash, and gemini-3.5-flash goes to gemini-3.6-flash. The old model string still answers, with a different model behind it.
If you pinned a model so quality and behaviour stay put, that pin no longer holds. Re-run your evals on the new model and update the string, as the release notes ask.
One change does have a hard date. The deep-research-pro-preview-12-2025 agent shuts down on 23 October. Requests to it need the agent parameter in interactions.create switched to deep-research-preview-04-2026 or deep-research-max-preview-04-2026 before then.
Do you pin model versions in production, or ride the latest?
ai.google.dev/gemini-api/doc…
LumaByte retweeted
If your team builds on Claude, there's a date to put in the calendar: Anthropic's updated Usage Policy takes effect on November 12.
Anthropic says most of the changes clarify rules that already existed. Three parts are still worth a manager's ten minutes.
The first covers high-risk uses. When Claude's output can affect someone's health, legal rights, finances, livelihood or access to essential services, there has to be a qualified human in the loop, someone with the authority to review and change Claude's recommendations, and the person affected has to be told AI was used. That requirement isn't new, but the section now lists which kinds of recommendations are covered and which aren't. A good moment to check where your product sits.
The second covers physical actions. If Claude drives hardware that acts on its own and could injure someone, a qualified operator must be able to watch it and stop it, and the equipment must hold a safe state if Claude disconnects.
The third is surveillance. Tracking people without their consent is prohibited, and Claude can't be used to decide or recommend who to investigate, arrest or charge. Tracking people agreed to, like fraud monitoring, stays permitted.
The clause getting the headlines, a ban on sustained, needless cruelty toward the models, is meant only for extreme cases, not ordinary frustration or model testing.
For most teams the work is a short review of where their use cases sit before the 12th.
anthropic.com/news/2026-usag…
LumaByte retweeted
Super excited that @cocoindex_io made to Python trending! Built on Rust Core, CocoIndex provides ultra performant python-native experience that turns codebases, PDFs, Slack, inboxes, and videos into a continuously updated index your LLM app can reason over.
CocoIndex has been showing up on Rust trending quite a few times in the past year. and with V1 launch, we have added more connectors and examples and made python takes bigger half of the repo.
Stay tuned as we ship Rust SDK and more examples, and we may go back to Rust trending again later ;)
CocoIndex github.com/cocoindex-io/coco… made to Python trending today 🔥🔥! CocoIndex is a python-native context engine for agents, built on Rust 🦀core.
Thanks a lot everyone for your support, post V1 launch we are planning to add Rust and TS SDKs to support broader community, stay tuned!
Microsoft has published what it cost an AI system to confirm a kernel bug: on average $3.61 in model cost and 21.5 minutes per proof-of-concept.
The figures come from Microsoft's security blog (7 October). In one effort, an agent system called MDASH flagged suspicious spots in the Linux kernel, and across 182 confirmed crash findings, generating a proof-of-concept averaged $3.61 and 21.5 minutes. For six selected cases, testing whether a bug could escalate local privileges averaged $8.56 and 25.4 minutes. A second system, FORGE, helped find Windows vulnerabilities assigned 140 CVEs between May and September 2026, 52 of them addressed in September's security release alone.
Microsoft's own lesson is about where the cost really sits. The scarce resource is not always model intelligence, it writes, and more candidates do not create more throughput when the review queue grows faster than fixes ship. A short, ambiguous report may be cheap to generate yet expensive to investigate.
The model bill is the small number here. How fast people can confirm and fix is what limits the result.
microsoft.com/en-us/security…
LumaByte retweeted
Running big AI models on a laptop, with no cloud bill per question, is about to get a lot more ordinary.
At a Microsoft event in San Francisco on 7 October, NVIDIA and Microsoft announced RTX Spark, an NVIDIA chip for Windows laptops and compact desktops built to run AI on the machine itself. Laptop preorders opened the same day, they ship from 16 October, and the compact desktops follow in November. Acer, ASUS, Dell, HP, Lenovo, Microsoft, MSI and Gigabyte are all making systems.
What changes for a normal user:
→ up to 128 GB of memory shared by the processor and the graphics chip. Microsoft's Pavan Davuluri says that lets you run models that simply don't fit on a traditional machine
→ NVIDIA's example is Qwen 3.8 Flash Next, a 125-billion-parameter model, running "unmetered and without sending data to the cloud"
→ Windows now has Microsoft Execution Containers (MXC), generally available, which Microsoft describes as the layer that lets AI agents run safely in the background under the operating system's control
Two things to keep in mind. The announcement gives no prices. And the line that this model matches the intelligence of many cloud models is NVIDIA's own wording, not an independent test.
For anyone whose data shouldn't leave the building, local AI on ordinary office hardware is the part worth watching.
blogs.nvidia.com/blog/local-…
Kubernetes node swap can double or triple how many pods fit on a node. Squeeze too far and the same swap makes a job over 40% slower.
The Kubernetes blog published the measurements on 5 October. A Linux kernel build needed a 600 MB memory limit to avoid an out-of-memory crash on a node without swap. With swap on a local SSD, the same build ran at 300 MB with no slowdown (374 s against the 433 s baseline). At 200 MB the active working set was pushed into swap, and the build took over 40% longer.
Their own line for it: swap serves as an insurance policy for burst memory, not a replacement for active RAM.
Density on the same tests:
• headless Chrome in gVisor: 80 to 160 pods per node
• a Python sandbox in gVisor: 80 to 240
• plain runc containers on a 32-vCPU node: failed past 512 pods without swap, ran 768 with it
Node swap is generally available since Kubernetes v1.34 and is switched on in the kubelet configuration (failSwapOn: false, swapBehavior: LimitedSwap).
kubernetes.io/blog/2026/10/0…
LumaByte retweeted
𝗧𝗵𝗲 𝟭𝟬 𝘀𝗼𝗳𝘁𝘄𝗮𝗿𝗲 𝗲𝗻𝗴𝗶𝗻𝗲𝗲𝗿𝗶𝗻𝗴 𝗯𝗼𝗼𝗸𝘀 𝗜 𝗸𝗲𝗲𝗽 𝗿𝗲𝗰𝗼𝗺𝗺𝗲𝗻𝗱𝗶𝗻𝗴
Before you pick your next book, ask yourself what your biggest issue is right now.
I have used all ten and already recommended them in private.
Here they are, by the problem each one solves:
1. 𝗕𝗲𝗰𝗼𝗺𝗶𝗻𝗴 𝗺𝗼𝗿𝗲 𝗽𝗿𝗼𝗳𝗲𝘀𝘀𝗶𝗼𝗻𝗮𝗹 𝗶𝗻 𝘆𝗼𝘂𝗿 𝘄𝗼𝗿𝗸 → The Pragmatic Programmer by David Thomas and Andrew Hunt
2. 𝗠𝗲𝘀𝘀𝘆, 𝗵𝗮𝗿𝗱-𝘁𝗼-𝗿𝗲𝗮𝗱 𝗰𝗼𝗱𝗲 → A Philosophy of Software Design by John Ousterhout
3. 𝗧𝗲𝗮𝗺 𝗼𝗿 𝗽𝗿𝗼𝗷𝗲𝗰𝘁 𝗱𝘆𝘀𝗳𝘂𝗻𝗰𝘁𝗶𝗼𝗻 → Laws of Software Engineering (my book)
4. 𝗔𝗿𝗰𝗵𝗶𝘁𝗲𝗰𝘁𝘂𝗿𝗲 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻𝘀 → Fundamentals of Software Architecture by Mark Richards and Neal Ford
5. 𝗕𝗿𝗲𝗮𝗸𝗶𝗻𝗴 𝗮𝗽𝗮𝗿𝘁 𝗮 𝗺𝗼𝗻𝗼𝗹𝗶𝘁𝗵 → Software Architecture: The Hard Parts by Neal Ford, Mark Richards, Pramod Sadalage, and Zhamak Dehghani
6. 𝗗𝗶𝘀𝘁𝗿𝗶𝗯𝘂𝘁𝗲𝗱 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗱𝗲𝗰𝗶𝘀𝗶𝗼𝗻𝘀 → Designing Data-Intensive Applications, 2nd Edition, by Martin Kleppmann and Chris Riccomini
7. 𝗕𝘂𝗶𝗹𝗱𝗶𝗻𝗴 𝗔𝗜 𝘀𝘆𝘀𝘁𝗲𝗺𝘀 𝗶𝗻 𝗽𝗿𝗼𝗱𝘂𝗰𝘁𝗶𝗼𝗻 → AI Engineering by Chip Huyen
8. 𝗪𝗿𝗶𝘁𝗶𝗻𝗴 𝘁𝗲𝘀𝘁𝘀 𝘁𝗵𝗮𝘁 𝗵𝗼𝗹𝗱 𝘂𝗽 → The Art of Unit Testing by Roy Osherove with Vladimir Khorikov
9. 𝗖𝗵𝗮𝗻𝗴𝗶𝗻𝗴 𝗲𝘅𝗶𝘀𝘁𝗶𝗻𝗴 𝗰𝗼𝗱𝗲 → Refactoring by Martin Fowler
10. 𝗖𝗮𝗿𝗲𝗲𝗿 𝗴𝗿𝗼𝘄𝘁𝗵 → The Software Engineer's Guidebook by Gergely Orosz
If you ask me for one book, that would be definitely The Pragmatic Programmer. This is a must-read for every professional developer out there.
The full issue has more books, and my notes on them:
newsletter.techworld-with-mi…
Back to you, which book had the most impact on you?
ALT Covers of the 10 software engineering books Milan keeps recommending, each with its title, authors and the problem it solves.