General approach

  • AI lies and doesn’t follow prompts. You can’t rely on AI as a source of information. Even if you ask something, you need to double-check afterwards. Without exceptions, unfortunately, if you care at all about the answer to the question.
  • AI can’t give a quality answer immediately. For images you need many generations to choose an acceptable one. For LLMs (and for images) you need to clarify the prompt several times (restart or chat). Conclusion: it’s practically impossible to design so that there will be one result, not many.
  • AI is quite slow: an image can generate for 30 seconds or more, the answer can also be long. Therefore, orientation toward batch approach: give a task, switch to another application and wait for notification that the answer is received.
  • Don’t count on AI knowing something. Better to give necessary data for analysis explicitly.
  • Cursor and other programming IDEs are good for LLMs, as they allow building local knowledge bases in text files (best UI for current LLMs).
  • The biggest problem with AI (especially text): you can’t trust them, i.e., you need to check everything, and this seems inefficient and long, so it’s hard to force yourself. Because of this, in the coming years there will continue to be mass problems for people who believed in AI answers.
  • Now we can talk about a slowdown in LLM development. In 2025 nothing noticeably new happened. The completed leap didn’t lead to any significant changes in the economy. Therefore, we can talk about a huge bubble in the stock market, which will more likely burst than hold until potentially possible real breakthroughs (though they’re not believed in at all; if breakthroughs happen, they’ll be in robots, not in GPU, clouds, and software). This also says that soon the mass fascination with AI in absolutely any software will move to the next stage: pioneers will abandon it and take up something else (or disappear as a class if a new hot topic isn’t found), and laggards will implement what more or less worked for pioneers.

Security

LLMs are extremely naive in prompts: they can’t distinguish user commands from data from third-party systems. For example, an attacker on a website can embed commands for LLM when it just tries to read them.

Intermediate conclusion: until there’s a fundamental shift in this issue, LLMs (and AI in general) can only work with safe data, not any from the internet.

Separately, you need to understand that sending data to the cloud – is sending data to the cloud, especially on free or cheap plans. Privacy leaks (both of some keys/passwords, and preferences for advertising) are only a matter of time.

Types of AI

Quite a lot in our lives:

  • LLM – models for working with text, but can accept images and sound as input (some).
  • image generation – works quite well even locally, but you need to know how to prepare. Can say it’s a separate profession.
  • video generation – something is appearing, but haven’t tried. Like images, only even more complex.
  • image modification – for example, background removal. Built into many graphics editors.
  • sound to text conversion – works well. Usually this is local whisper from OpenAI.
  • song generation – haven’t tried myself, but heard many amazing ones
  • text to speech – seems to exist, but don’t even know how it is now
  • image to text recognition – it’s so old that many don’t think it’s AI. Now built right into macOS.

some other directions?

Local LLM models

Several levels can be distinguished:

  • mobile (somewhere up to 3-4b) – answer something, but practically know nothing (can somehow use for processing transmitted text, but in practice don’t use). Can make something specialized, but unclear why.
  • small (somewhere up to 7-8b) – so-so, but fast
  • medium (somewhere 12b) – better, but slower
  • large (20b) – fits in 32GB combined memory, should have agent network architecture to work fast.
  • huge (80b-400b) – requires special hardware (not just 1 gaming card or Apple processor). Seems quite good, almost like cloud, but expensive (around 1 million rubles for hardware).

gpt-oss:20b – very good compared to other local ones. Both answers well and fast. And works with MCP. Can say the discovery of the year.

Local programs

  • Whispering – UI for dictating text (free & open source)
  • Pixelmator Pro – one-time purchase from Apple, this is some local AI (for example, remove background or erase something)
  • AI Playground plugin for JetBrains – allows running one query on several models to compare their quality
  • good review of text 2 speech: https://habr.com/ru/companies/ntechlab/articles/854724/

Ways to give data to the model

There are many ways: manually in prompt, RAG, retrain model, MCP, skills. Skills is the latest in this set (recently announced), but MCP still looks best (if the model can work with it, many local ones can’t).

Programming with AI

  • AI fixes errors quite well
  • AI can write tests that give high coverage (90+%). Good that there’s a second look at code, not the same programmer designing tests (strength of pair programming).
  • AI formats or changes text quite well (from logs make curl or from logs take json and format)
  • AI is useless in documentation and understanding projects: yes, you can generate documentation, but it’s more of a helper for subsequent AI commands than for people. For people it’s rather harmful: a person didn’t index the source code themselves, which is important for further quality work, and summary is trivial after indexing, and by itself without indexing usually isn’t needed. The thesis deserves a separate article, but we’ll be brief.
  • AI replaces stackoverflow and other sites with code examples: it immediately adapts the example to our situation. In other words, this way you can quickly understand new APIs and syntax. However, as when using code from sites, you need to understand it deeply and fix it, as often it’s not entirely correct (more like a hint than ready code).
  • You need to create brief instructions (rules) to adapt LLM to our project and not write an explicitly long prompt every time.
  • It’s quite easy to do various simple things and prototypes. For example, a local llm in 2 short prompts (main and clarification that on error you need to pause) made such a multiplication learning page for children: https://stepin.name/x

However:

  • formatting and code quality utilities should remain on explicit rules, this works better now
  • Cursor is terrible as an IDE, only generate code in it, manual edits in another
  • proposed AI code needs to be understood and improved. Quite often it’s bad.
  • test code size is huge, unclear whether to spend time understanding it, fixing it, or just not write tests like that. Either somehow strictly specify how to write tests, or something else. For now an open question how to best write tests with AI.

In the end:

  • AI makes juniors useless, which complicates the influx of new people into the profession
  • AI won’t replace programmers, as “nagging” with LLM will always need someone. Perhaps, after some time programming will be more about specifications and design, but we’ve been going in this direction for the last 30 years, nothing new. Even in the early 2000s they said that pure programmers aren’t needed, needed are those who understand the specifics of the direction for which software is written.
  • I don’t have a ready recipe yet for how to work with tests using AI, still trying different approaches.
  • AI is another new tool that needs to be known and able to use. So again everything got more complicated, not simpler.