AI coding agents take the shortest path to done, which usually means skipping the specs, tests, and reviews that make software reliable at scale. Agent Skill...

https://x.com/datachaz/status/2040357775830814798?s=43&t=gAZhA3-2h2DvLb-eSzGa5A

https://github.com/addyosmani/agent-skills

@addyosmani
from Google just dropped his new Agent Skills and it's incredible.

It brings 19 engineering skills + 7 commands to AI coding agents, all inspired by Google best practices 🤯

AI coding agents are powerful, but left alone, they take shortcuts.

They skip specs, tests, and security reviews, optimizing for "done" over "correct." Addy built this to fix that.

Each skill encodes the workflows and quality gates that senior engineers actually use: spec before code, test before merge, measure before optimize.

The full lifecycle is covered:

→ Define - refine ideas, write specs before a single line of code
→ Plan - decompose into small, verifiable tasks
→ Build - incremental implementation, context engineering, clean API design
→ Verify - TDD, browser testing with DevTools, systematic debugging
→ Review - code quality, security hardening, performance optimization
→ Ship - git workflow, CI/CD, ADRs, pre-launch checklists

Features 7 slash commands: (/spec, /plan, /build, /test, /review, /code-simplify, /ship) that map to this lifecycle.

https://news.ycombinator.com/item?id=45652952

According to the DeepSeek paper, you can pull out 10 text tokens from a single image token with near-100% accuracy. In other words, a model’s internal representation of an image is ten times as efficient as its internal representation of text. Does this mean that models shouldn’t consume text at all? When I paste a few paragraphs into ChatGPT, would it be more efficient to convert that into an image of text before sending it to the model? Can we supply 10x or 20x more data to a model at inference time by supplying it as an image of text instead of text itself?

Building in NY. Dicklesworthstone has 179 repositories available. Follow their code on GitHub.

People think they can use Fine-Tune for Knowledge Injection. People are Wrong

https://news.ycombinator.com/item?id=44242737

If fine-tuning is a risky solution, what’s the alternative? The answer lies in modularity and augmentation. Techniques such as retrieval-augmented generation (RAG), external memory banks, and adapter modules provide more robust ways to incorporate new information without overwriting the existing network’s knowledge base.

Free image background removal - private, client-side and powered by Transformers.js - addyosmani/bg-remove

https://bg.addy.ie/

https://fortune.com/2025/11/11/why-ai-adoption-is-failing-seven-mistakes/
November 11, 2025

Mistake #1: The business goal isn’t crystal clear
The fix: Be precise. Be clear. Take the time up front to crystallize the problem and expected ROI with all stakeholders right off the bat.

Mistake #2: The project is poorly managed

Mistake #3: You’re overpromising. Believing AI will solve everything is a recipe for disappointment

Mistake #4: Vastly underestimating the resources required

Mistake #5: Ignoring reality

Mistake #6: No offense, but your data quality is bad

Mistake #7: Think the project’s done? Not quite
While AI projects may have a clear start and finish, the work doesn’t end when the model is operationalized. AI systems are dynamic and models can drift, data can evolve and outputs can degrade over time. Treating AI like a “set it and forget it” initiative is a costly mistake. Without continuous monitoring, evaluation, and updates, your AI solution may lose accuracy, relevance, and trustworthiness.

AI is bad at making things that are great. It's also bad at making things that are bad. The second half is the part worth talking about.

The trap isn’t AI. The trap is that 7 is easier to reach than it’s ever been, and 7 feels like enough.

The middle has never been more crowded. The interesting work is on the edges — the 1s and the 9s — and only one of those edges is still accessible to a tool. The other one is accessible to you, if you remember how to get there.

The skill now might just be knowing what a 1 used to feel like. And being a little suspicious of anything that lands at a 5.

Googles system prompt of the CLI is heavily flawed IMO. That's where most problems arise. I am using a custom one. At least it is highly configurable. The vanilla Gemini Cli is not usable for me. For instance, they have a section they introduce with Proactiveness where they give advice about what is Persistence (in the agent loop). This wrong wording alone causes the agent to be "proactive" in many ways that is not wanted. After I asked the model itself once, why it started to scan my entire codebase when I just asked to create a new branch, it directly said to me there is "Proactiveness" in its system prompt. I was baffled, why would anybody want that? So i digged deeper and did also a thorough analysis with Opus 4.7 of just this system prompt file - that cost me an entire Pro-session btw. - and documented the results in this pr: https://github.com/google-gemini/gemini-cli/pull/26129 - I am using the optimized prompt and had no issues so far I had with the original one.

Another big issue is "model panic" - the Gemini model often overwrites entire files "from memory" with write_file, when the edit tool fails 2 times. That occasionally causes code degradation, and when there are multiple turns and there is no backup, the model starts to get nuts, trying to fix its errors, and destroys even more in the effort to just make it compile / build. I gave it a rotating pre-write backup and a restore_file tool. The model panic vanished. https://github.com/google-gemini/gemini-cli/pull/25947

With these two fixes, Gemini CLI is pretty good - without them I wouldn't use it.

For all of the AI industry’s advancements, the major models like ChatGPT and Claude still struggle with PDFs, one of the oldest and ubiquitous file formats.

I have literally never seen LLM writing that actually improved my life.

The model produces better work. Some of my peers believe that large language models produce strictly better writing than they could produce on their own. Anecdotally, this phenomenon seems more common among English-as-a-second-language speakers. I also see it a lot with first-time programmers, for whom programming is a set of mysterious incantations to be memorized and recited. I think this is also the cause of language model use in some forms of academic writing: it differs from the prior case with paper reviews in that, presumably, the authors believe that their paper matters, but don’t believe they can produce sufficient writing

I work to bring AI into production. I write about AI system design.

When performing multi-turn operations (specifically Function Calling), the client must pass this signature back in the subsequent request. This ensures the model resumes execution from the exact state where it halted, rather than re-computing context from the raw message history. Omission results in an invalid_argument error or non-deterministic behavior.

Stanford's Jeremy Utley reveals that "most people are not fully utilizing AI's potential." Why is that? He explains that it lies in how we approach AI. He said a simple mindset shift could be what you've been missing in the AI revolution.

Creativity is doing more than the first thing you think of

Think of LLM as a teammate and not just a tool. Provide it feedback! Let it ask you questions!

Key Insights:
📌How treating AI as a teammate rather than just a tool can dramatically improve outcomes
📌Why you should have AI ask you questions instead of just answering yours
📌How non-technical professionals can leverage AI to achieve extraordinary results
📌The difference between treating AI as a tool versus as a teammate

00:00 Intro

If you want to learn more about creativity using AI with Professor Jeremy, please refer to the link below!
👉 https://www.jeremyutley.design/ai-newsletter

We have decades of experience trying to automate processes. The biggest lesson is that automation is not about the easy and known flow, but about exception handling.

The best diagnosis for exception handling I can think of is to wait on line at the post office. If you’ve ever done that, you know the thought of “doesn’t anyone just want to mail a package” comes to mind. As it turns out the entire flow at the post office (or DMV or tax office) is about exception handling. No amount of software is going to get you out of there because it is piecing together a bunch of inputs and outputs that are outside the bounds of a system.

The ability to automate hinges not just on the ability to know the steps to take for predefined inputs, and not even the steps to take if some inputs are erroneous or incomplete, but what to do if you can’t even specify the inputs.

My favorite example of the latter is how the arrival of IBM computing in the 60s and 70s totally changed the definition of accounting, inventory control, and business operations. Every process that was "computerized" ultimately looked nothing at all like what was going on under those green eyeshades in accounting. Much of the early internet (and still most bank and insurance) look like HTML front ends to mainframe 3270 screens. Those might eventually change, just not quickly. It might be that the "legacy" or "installed base" of many processes is such that the cost to change is too monumental.

https://news.ycombinator.com/item?id=41765594

My favorite (evidence backed) theory on how humans learn is Retrieval Practice.
https://www.learningscientists.org/blog/2024/3/7/how-does-retrieval-improve-new-learning

Humans don’t really learn when we download info into our brain, we learn when we expend effort to pull that info out. This has some big implications for designing collaborative tooling!

The “thing” that we learn most effectively is not knowledge as we typically think of it, it’s process. This should be intuitive, if we put into a bit of a more natural context. Imaging learning baking for a moment: Do you teach someone to bake a cake by spitting out a fact sheet of ingredients and having them memorize it? Or do you teach them the process?

It was like a revelation when chain-of-thought AI became viral news as a GitHub project that supposedly competed with SOTA's with only 2 developers and some nifty prompting...
Did all the companies just jump on the bandwagon an weave it into GPT/ Gemini / Claude in a hurry?
Did those companies already have e.g. Gemini 2.5 PRO thinking in development 4 months ago and we didn't know?

For tech and AI talent, jobs at financial services companies are more desirable than they have ever been. Banks have been working hard to make it happen.

Why LLMs will transform development but not how you think

it's about how AI tools are enabling a new category of software that simply couldn't exist before.

When someone can describe their specific needs conversationally and receive working code in response, the economics of personal software development shift dramatically.

Think of it this way: just as spreadsheets enabled non-programmers to perform complex calculations and data analysis, AI-assisted development tools are enabling non-programmers to create personal software solutions.

Picking your general-purpose AI

Also:

https://www.oneusefulthing.org/p/doing-stuff-with-ai-opinionated-midyear