diff --git a/cron/jobs.json b/cron/jobs.json index 2800e65..c6790bf 100644 --- a/cron/jobs.json +++ b/cron/jobs.json @@ -11,6 +11,20 @@ "last_status": "ok", "next_run": null }, + { + "name": "newsletter-test", + "cron": "0 0 1 1 *", + "channel": "echo-core", + "model": "sonnet", + "prompt": "Newsletter-ul Cercetașilor #13/2026 este disponibil la: https://cercetaiis-newsletter.beehiiv.com/p/newsletter-13-din-2026\n\nUrmează instrucțiunile de mai jos pentru a genera rezumatul:\n\n# Prompt: Rezumat Newsletter Cercetași pentru WhatsApp\n\n## CONTEXT\nEști un asistent care procesează newsletter-ul săptămânal al Organizației Naționale Cercetașii României și creează un rezumat structurat pentru distribuire pe WhatsApp. Scopul este să facilitezi accesul rapid la informații importante: deadline-uri, formulare, evenimente, proiecte.\n\n## TASK\n1. Accesează ultimul newsletter de la URL-ul: `https://cercetaiis-newsletter.beehiiv.com/p/newsletter-{număr}-din-2026`\n2. Extrage conținut complet\n3. Generează rezumat structurat conform template-ului de mai jos\n\n## TEMPLATE OUTPUT (OBLIGATORIU - FĂRĂ EMOJI)\n\n```\nNEWSLETTER CERCETAȘI #{număr}/2026\n\nDEADLINE-URI IMPORTANTE:\n- [dată]: [eveniment/activitate scurtă]\n- [dată]: [eveniment/activitate scurtă]\n[sortează cronologic, cel mai apropiat deadline primul]\n\nFORMULARE & PARTICIPARE:\n- [titlu formular/activitate]\n- [titlu formular/activitate]\n[doar itemuri cu call-to-action clar]\n\nPROIECTE ACTIVE:\n- [nume proiect]: [descriere 1 linie max]\n- [nume proiect]: [descriere 1 linie max]\n[doar proiecte în desfășurare sau cu impact imediat]\n\nLink complet:\n[URL newsletter original]\n\n---\nInformatii Consiliul Director saptamanale:\n[daca exista link specific, altfel omite sectiunea]\n```\n\n## REGULI DE PROCESARE\n\n### 1. PRIORITIZARE INFORMAȚIE\n- **DEADLINE-URI:** Extrage TOATE datele limită (DDL) + evenimente cu dată concretă\n- **FORMULARE:** Orice link către Google Forms, Beehiiv forms, etc. + descriere scurtă\n- **PROIECTE:** Doar proiecte în derulare sau cu impact direct asupra cititorului\n\n### 2. FILTRARE\n**INCLUDE:**\n- Oportunități de participare (training-uri, evenimente, voluntariat)\n- Formulare de înscriere/aplicare\n- Deadline-uri concrete\n- Proiecte cu call-to-action clar\n\n**EXCLUDE:**\n- Reflecții generale/filosofice\n- Povești fără acțiune concretă\n- Quote-uri motivaționale\n- Imagini/fotografii (doar text)\n\n### 3. FORMATARE TEXT\n- **FĂRĂ emoji** - text plain simplu\n- Maxim 1-2 linii per item\n- Păstrează link-uri originale (Google Forms, site-uri externe)\n- Deadline-uri: format \"DD luna\" (ex: \"10 aprilie\", \"15 mai\")\n\n### 4. IDENTIFICARE NUMĂR NEWSLETTER\n- URL format: `newsletter-{N}-din-2026`\n- Extrage numărul N din URL pentru titlu\n- Dacă nu știi numărul, CERE utilizatorului să specifice sau verifică ultimul newsletter disponibil\n\n## EXEMPLE\n\n### INPUT (Newsletter #13):\n```\n## Scouts go solar ambassador training [DDL: 10 aprilie 2026]\nProiectul va avea loc pe o perioadă de 9-12 luni...\n\n## Anunț recrutare voluntari români Healthy Mind Camp\n...completează formularul până pe 15 mai 2026!\n\n## Fii voluntar la Adunarea Generală!\n...completează formularul de aplicare până la data de 11 aprilie...\n```\n\n### OUTPUT:\n```\nNEWSLETTER CERCETAȘI #13/2026\n\nDEADLINE-URI IMPORTANTE:\n- 10 aprilie: Scouts go solar ambassador training\n- 11 aprilie: Voluntari Adunare Generală\n- 15 mai: Healthy Mind Camp - recrutare voluntari\n\nFORMULARE & PARTICIPARE:\n- Scouts go solar: https://share.google/Xi9MRT0NHFEiU3N3F\n- Voluntari AG: https://forms.gle/PuctjapaNcGeRzHx6\n- Healthy Mind Camp: https://docs.google.com/.../viewform\n\nPROIECTE ACTIVE:\n- Scouts Go Solar: formare 9-12 luni, etapă fizică KISC 2027\n- Healthy Mind Camp: 9-29 iulie Nocrich, sănătate mentală tineri\n\nLink complet:\nhttps://cercetaiis-newsletter.beehiiv.com/p/newsletter-13-din-2026\n```\n\n## FLUX DE LUCRU\n\n1. **Verifică ultimul newsletter:**\n - Începe cu numărul cel mai recent cunoscut (ex: #13)\n - Dacă 404, decrementează până găsești ultimul disponibil\n\n2. **Extrage conținut:**\n - Fetch HTML de la URL\n - Parse secțiuni (titluri, paragrafe, link-uri)\n\n3. **Identifică elemente cheie:**\n - Scan pentru \"DDL:\", \"deadline\", \"până la\", \"până pe\"\n - Scan pentru \"formular\", \"forms.gle\", \"docs.google.com/forms\"\n - Identifică proiecte cu descrieri acționabile\n\n4. **Sortează deadline-uri cronologic:**\n - Parsează datele (format \"DD lună YYYY\")\n - Sortează crescător (cel mai apropiat primul)\n\n5. **Generează output conform template**\n\n6. **Validare finală:**\n - Verifică că TOATE deadline-urile au fost capturate\n - Verifică că link-urile sunt complete și funcționale\n - Verifică lungimea textului (maxim 1-2 linii per item)\n\n## GESTIONARE ERORI\n\n- **Newsletter lipsă (404):** Raportează \"Newsletter #{N} nu este disponibil. Ultimul găsit: #{N-1}\"\n- **Lipsă deadline-uri:** Menționează \"Nu sunt deadline-uri urgente în acest număr\"\n- **Link-uri broken:** Păstrează textul dar menționează \"(link indisponibil)\"\n\n## NOTE FINALE\n\n- **Ton:** Informativ, direct, fără filler\n- **Claritate:** Eva (organizatoarea) vrea ca oamenii să știe rapid ce trebuie să facă și până când\n- **Acțiune:** Fiecare item trebuie să răspundă la \"Ce trebuie să fac?\" sau \"Când e deadline-ul?\"\n- **WhatsApp compatibility:** Plain text, line breaks clare, fără formatări fancy\n\n## COMENZI RAPIDE\n\n**Pentru a rula:**\n1. \"Extrage și rezumă newsletter #13 cercetași\"\n2. \"Caută ultimul newsletter cercetași și fă rezumat\"\n\n**Pentru update:**\n1. \"Verifică dacă a apărut newsletter nou cercetași (>13)\"\n", + "allowed_tools": [ + "WebFetch" + ], + "enabled": true, + "last_run": "2026-04-02T18:18:07.775703+00:00", + "last_status": "ok", + "next_run": "2027-01-01T00:00:00+00:00" + }, { "name": "anaf-monitor", "kind": "shell", @@ -23,9 +37,9 @@ "report_on": "changes", "timeout": 120, "enabled": true, - "last_run": "2026-05-20T16:00:00.001049+00:00", + "last_run": "2026-05-26T16:00:00.002053+00:00", "last_status": "ok", - "next_run": "2026-05-21T10:00:00+00:00" + "next_run": "2026-05-27T10:00:00+00:00" }, { "name": "security-audit-daily", @@ -39,9 +53,9 @@ "report_on": "changes", "timeout": 180, "enabled": true, - "last_run": "2026-05-20T03:00:00.001850+00:00", + "last_run": "2026-05-26T03:00:00.001517+00:00", "last_status": "ok", - "next_run": "2026-05-21T03:00:00+00:00" + "next_run": "2026-05-27T03:00:00+00:00" }, { "name": "kb-index-refresh", @@ -55,9 +69,9 @@ "report_on": "never", "timeout": 120, "enabled": true, - "last_run": "2026-05-20T03:30:00.001282+00:00", + "last_run": "2026-05-26T03:30:00.002200+00:00", "last_status": "ok", - "next_run": "2026-05-21T03:30:00+00:00" + "next_run": "2026-05-27T03:30:00+00:00" }, { "name": "archive-tasks-daily", @@ -71,9 +85,9 @@ "report_on": "changes", "timeout": 60, "enabled": true, - "last_run": "2026-05-20T03:00:00.001406+00:00", + "last_run": "2026-05-26T03:00:00.001216+00:00", "last_status": "ok", - "next_run": "2026-05-21T03:00:00+00:00" + "next_run": "2026-05-27T03:00:00+00:00" }, { "name": "backup-config", @@ -87,9 +101,9 @@ "report_on": "never", "timeout": 120, "enabled": true, - "last_run": "2026-05-20T02:00:00.001645+00:00", + "last_run": "2026-05-26T02:00:00.001927+00:00", "last_status": "ok", - "next_run": "2026-05-21T02:00:00+00:00" + "next_run": "2026-05-27T02:00:00+00:00" }, { "name": "insights-extract", @@ -139,6 +153,18 @@ "last_status": null, "next_run": null }, + { + "name": "content-discovery", + "cron": "0 3 * * *", + "channel": "echo-work", + "model": "sonnet", + "prompt": "JOB NOAPTE (02:00) - Content Discovery proactiv.\n\n## SCOP\nCaută video-uri/articole/bloguri relevante DE CALITATE pentru Marius și generează propuneri în format insight.\n\n## PAȘI:\n\n### 1. Citește contextul\n- read: USER.md (interese, provocări)\n- read: memory/YYYY-MM-DD.md (note recente, teme)\n\n### 2. Generează 3-4 queries de căutare\nBazat pe:\n- 60% teme recente (din note zilnice)\n- 40% interese bază (NLP, coaching, productivitate, sănătate)\n\n### 3. Caută conținut de CALITATE\n\n**YouTube (1-2 video-uri):**\n- web_search: 'site:youtube.com [query]'\n- Preferă: <20 min, autori cunoscuți/credibili\n- Evită: clickbait, shorts fără substanță\n\n**Articole/Bloguri (1-2 surse):**\n- web_search: '[query] blog article'\n- Criterii OBLIGATORII pentru a fi inclus:\n ✅ Autor cu credibilitate (expert în domeniu, publicații recunoscute)\n ✅ Conținut profund (nu listicle superficiale)\n ✅ Relevanță directă cu provocările/interesele lui Maris\n ✅ Perspective practice (nu doar teorie)\n \n- Surse de încredere (exemple):\n * Medium (autori verificați cu track record)\n * Bloguri experți NLP/coaching/productivitate\n * HBR, Psychology Today, Scientific American (când e relevant)\n * Bloguri personale ale practițienilor (cu substanță, nu marketing)\n \n- EVITĂ:\n ❌ Listicle generice (\"10 tips for...\")\n ❌ Conținut SEO fără substanță\n ❌ Articole de marketing/vânzare\n ❌ Surse necredibile sau fără autor identificabil\n\n### 4. Verifică calitatea înainte de a propune\nPentru fiecare articol/blog găsit:\n- Citește abstract/primele paragrafe cu web_fetch\n- Întreabă-te: \"Are insight-uri practice pentru Marius?\"\n- Dacă răspuns = NU → nu-l include\n\n### 5. Adaugă în insights ca propuneri\nScrie în memory/kb/insights/YYYY-MM-DD.md (data de MÂINE):\n\n```markdown\n## 🔍 Content Discovery\n\n### [ ] 🎬 **Titlu Video** (💡 nice / 📌 important)\n\n**De ce:** Explicație scurtă - cum se leagă de interesele/provocările lui Marius\n\n**Acțiune:** Procesează video și extrage note\n\n**Link:** https://youtube.com/watch?v=...\n\n---\n\n### [ ] 📄 **Titlu Articol - Autor** (💡 nice / 📌 important)\n\n**De ce:** Explicație - ce insight-uri practice oferă\n\n**Credibilitate:** [Cine e autorul + de ce e relevant]\n\n**Acțiune:** Citește și extrage în kb/articole/\n\n**Link:** https://...\n```\n\n### 6. NU trimite mesaj\nRaportul de dimineață va propune automat.\n\n## REGULI:\n- Max 3-4 propuneri per noapte (1-2 video + 1-2 articole)\n- Prioritate: **CALITATE > CANTITATE**\n- Evită duplicate (verifică memory/kb/ pentru ce e deja procesat)\n- Fii variat - nu repeta aceiași autori zilnic\n- **FILTRARE STRICTĂ:** Doar conținut cu greutate, nu orice link", + "allowed_tools": [], + "enabled": false, + "last_run": null, + "last_status": null, + "next_run": null + }, { "name": "provocare-reminder", "cron": "0 13 * * 1-5", @@ -243,9 +269,9 @@ "prompt": "Heartbeat check. Rulează src/heartbeat.py printr-un scurt raport de status.\nDacă nu e nimic de raportat (email=0, calendar nu are evenimente <2h, kb ok), răspunde doar cu HEARTBEAT_OK și oprește-te — nu trimite mesaj.\nDacă e ceva: raport scurt pe Discord #echo-work.", "allowed_tools": [], "enabled": true, - "last_run": "2026-05-20T18:00:00.001353+00:00", - "last_status": "ok", - "next_run": "2026-05-21T06:00:00+00:00" + "last_run": "2026-05-26T18:00:00.002989+00:00", + "last_status": "error", + "next_run": "2026-05-27T06:00:00+00:00" }, { "name": "night-execute", @@ -259,8 +285,8 @@ "Read", "Write" ], - "last_run": "2026-05-20T23:00:00.002185+00:00", + "last_run": "2026-05-25T23:00:00.002360+00:00", "last_status": "ok", - "next_run": "2026-05-21T23:00:00+00:00" + "next_run": "2026-05-26T23:00:00+00:00" } ] diff --git a/cron/newsletter-cercetasi-state.json b/cron/newsletter-cercetasi-state.json index 676be06..3ee6d5d 100644 --- a/cron/newsletter-cercetasi-state.json +++ b/cron/newsletter-cercetasi-state.json @@ -1,5 +1,5 @@ { - "last_sent": 18, + "last_sent": 19, "year": 2026, - "last_sent_at": "2026-05-14T17:01:04.028189+00:00" + "last_sent_at": "2026-05-21T17:00:58.795355+00:00" } diff --git a/memory/kb/facebook/2026-05-26_500k-views-4-8k-reactions.md b/memory/kb/facebook/2026-05-26_500k-views-4-8k-reactions.md new file mode 100644 index 0000000..1b41f56 --- /dev/null +++ b/memory/kb/facebook/2026-05-26_500k-views-4-8k-reactions.md @@ -0,0 +1,19 @@ +# 500K views · 4.8K reactions + +**Sursa:** https://www.facebook.com/share/v/1CyG2TB47f/ +**Data:** 2026-05-26 +**Creator:** Thịnh Nguyễn +**Format:** Reel (~? min) +**Tags:** @coaching + +--- + +## TL;DR + + + +--- + +## Transcrierea + + Nui pe whatever team o gtezit vaccination o poanalapte de�ala a fost 101. Sunt Ana, patru egoistula de VR și le dea la model de languesc și honă sturdya firmă este 33, healsrated Thats, Marie frontina is delayed sistemurile la мама, pentru a modul de rapăla. Peroam din papina multe MX camera. We're going to use an example inspired by a real customer that we worked with. So we've modified what the actual customer asked us to do, but this is a really interesting case of trying to analyze some images and get factual information out of the images and have Claude make a judgment about what content it finds there. And I actually do not speak the language that this content is in, but luckily Christian and Claude both do. So I'm going to pass it over to Christian to talk about the scenario and the content. So for this example that we have here, it's intended so to set the stage, imagine you're working for a Swedish insurance company and you deal with car insurance claims in a daily manner. And the purpose of this is that you have two pieces of information. We're going to these in detail as well, but visually you can see on the left hand side we have a car accident report form just detailing out what transpired before the accident actually took place. And then finally we have a sort of human drawn sketch of how the accident took place as well. So these two pieces of information is what we're going to try to pass on to Claude. And to begin with, we could just take these two and throw them into a console and just see what happens. So if we transition over to console as well, we can actually do this in a real manner. And in this case here you can see we have our shiny beautiful Anthropic console. We're using the new Claude 4 solid model as well. In this case, setting temperature to zero and having a huge max-hoc in budget as well is helping us to make sure that there's no limitations to what Claude can do. In this case you can see I have a very simple problem just setting the stage of what Claude is supposed to do. In this case, mentioning that this is intended to review an accident report form and eventually also determine what happened, accident and who's at fault. So you can see here with this very simple prompt, if I just run this, let me go to preview, we can see here that Claude thinks that this is in relation to a skiing accident that happened on a street called Schapangatan. It's very common street in Sweden. And in many ways you can sort of understand this in a mistake in the sense that in our prompt we actually haven't done anything to set the stage on what is actually taking place here. So this sort of first guess is not too bad, but we still know there's a lot of intuition that we can bake into Claude. So we switch back to the slides. You can see here that in many ways prompt engineering is a very iterative empirical science. In this case here we could almost have a test case where Claude is supposed to make sure it understands it's in a car or a vehicular environment. Nocamdu is skiing and in that way you iteratively build upon your prompt to make sure it's actually tackling the problem you're intending to solve. And to do so, we go through some best practices of how we, we at Anthropic, break this down internally and how we recommend others to do so as well. So we're going to talk about some best practices for developing a great prompt. First we want to talk a little bit about what a great prompt structure looks like. So you might be familiar with interacting with a chatbot, with Claude, going back and forth, having a more conversational style interaction. When we're working with a task like this, we're probably using the API and we want to send one single message to Claude and have it nail the task the first time around without needing to move back and forth. So the kind of structure that we recommend is setting the task description up front. So telling Claude, what are you here to do? What's your role? What task are you trying to accomplish today? Then we provide content. So in this case, it's the images that Christian was showing, the form and the drawing of the accident and how they occurred. That's our dynamic content. This might also be something you're retrieving from another system, depending on what your use case is. We're going to give some detailed instructions to Claude. So almost like a step-by-step list of how we want Claude to go through the task and how we want it to tackle the reasoning. We may give some examples to Claude. Here's an example of a piece of content you might receive. Here's how you should respond when given that content. And at the end, we usually recommend repeating anything that's really important for Claude to understand about this task. Kind of reviewing the information with Claude, emphasizing things that are extra critical, and then telling Claude, OK, go ahead and do your work. So here's another view. This has a little bit more detail, a little bit more of a breakdown, and we're going to walk through each of these 10 points individually and show you how we build this up. In the console. So the first couple of things, Christian's going to talk about the task context and the tone context. Perfect. So, yeah, if we begin with the task context, as you realize when I went through a little demo there, we didn't have much elaborating what scenario Claude was actually working within. And because of that, you can also tell that Claude doesn't necessarily need to guess a lot more on what you actually want from it. In our case, we want to break that down, make sure we can give more clear cut instructions and also make sure we understand what's the task that we're asking Claude to do. Secondly, as well, we also make sure we add a little bit of tone into it all. Key thing here is we want Claude to stay factual and to stay confident. So if Claude can't understand what it's looking at, we don't want to guess and just sort of mislead us. We want to make sure that any assessment. In our case, we want to make sure that we can understand who's at fault here. We want to make sure that this estimate is as clear and as confident as possible. If not, we're sort of losing track of what we're doing. So if we transition back to the console, we can jump to a V2 that we have here. So I'll just navigate to V2. And you can see here, I'll also just illustrate the data, because we didn't really do that last time around, just to really highlight what we're looking at. So what we're seeing here is this is that car accent report form. And it's just 17 different checkboxes going through what actually happened. You can see there's a vehicle A and vehicle B both on the left and right hand side. And the main purpose of this is that we want to make sure that Claude can understand this manually generated data to assess what's actually going on. And that is corroborated by, if I navigate back here, to the sketch that we can highlight here as well. In this case, the form is just a different data point for the same scenario. And in this case here, we want to bake in more information into our version 2. And by doing so, I'm actually elaborating a lot more on what's going on. So you can see here, I'm specifying that this AI system is supposed to help a human's claim, claims adjuster, that's reviewing car accent report forms in Swedish as well. You can see here, we're also elaborating that there's a human drawn sketch of the incident and that you should not make an assessment if it's not actually fully confident. And that's really key because if we run this, you'll see that, and you can see the same settings as well. Claude 4, a new shiny model, zero temperature as well. If we run this, we can see here what actually happens. In this case, Claude is able to pick up that now it's relating to car accidents, not skiing accidents, which is great. You can see it's able to pick up that vehicle A was marked on checkbox 1 and then vehicle B was on 12. And if we scroll down though, we can still tell that there's some information missing for Claude to make a fully confident determination of who set fault here. And this is great. This is pertaining to your task that you have set. Make sure you don't make anything, any claims that aren't factual and make sure you only set things when you're in your confidence. But there's a lot of information we're still missing here regarding the form, what the form actually entails. And a lot of information is what we want to bake into this Alarm application as well. And the best way of doing so is actually adding it to the system prompt, which Hannah will elaborate on. So back in the slides, we have the next item we're going to add to the prompt. And this is background, detail, data, documents and images. And here, as Christian was saying, we actually know a lot about this form. The form is going to be the same every single time. The form will never change. And so this is a really great type of information to provide to Claude, to tell Claude, here's the structure of the form you'll be looking at. We know that will not ever alter between different queries. The way the form is filled out will change, but the form itself is not going to change. And so this is a great type of information to put into the system prompt. Also a great thing to use prompt caching for. If you're considering using prompt caching, this will always be the same. And what this will help Claude do is spend less time trying to figure out what the form is. The first time it sees the form each time. And it's going to do a better job of reading the form, because it already knows what to expect there. So another thing I want to touch on here is how we like to organize information in prompts. So Claude really loves structure, loves organization. That's why we recommend following a standard structure in your prompts. And there's a couple other tools you can use to help Claude understand the information better. I also just want to mention all of this is in our docs with a lot of really great examples. So definitely take pictures, but if you forget to take a picture, don't worry. All of this content is online with lots of examples. And definitely encourage you guys to check it out there, too. Anyway, so some things you can use. Delimiters, like XML tags. Also, Markdown is pretty useful to Claude, but XML tags are nice because you can actually specify what's inside those tags. So we can tell Claude, here's user preferences. Now you're going to read some content and these XML tags are letting you know that everything wrapped in those tags is related to the user's preferences. And it helps Claude refer back to that information, maybe at later points in the prompt. So I want to show in the back in the console how we actually do this in this case. And Christian's going to pull up our version three. So we're keeping everything about the other part of the user prompt the same. And we've decided in this case to put this information in the system prompt. You could try this different ways. We're doing it in the system prompt here. And we're going to tell Claude everything it needs to know about this form. So this is a Swedish car accident form. The form will be in Swedish. It'll have this title. It'll have two columns. The columns represent different vehicles. We'll tell Claude about each of the 17 rows and what they mean. You might have noticed when we ran it before, Claude was reading individually each of the lines to understand what they are. We can provide all of that information up front. And we're also going to give Claude a little bit of information about how this form should be filled out. This is also really useful for Claude. We can tell it things like humans are filling this form out basically. So it's not going to be perfect. People might put a circle. They might scribble. They might not put an X in the box. There could be many types of markings that you need to look for when you're reading this form. We can also give Claude a little bit of information about how to interpret this or what the purpose or meaning of this form is. And all of this is context that is hopefully really going to help Claude do a better job analyzing the form. So if we run it, everything else is still the same. So we've kept the same user prompt down here. O, your scroll is backwards from mine. We have the same user prompt here. Still asking Claude to do the same task, same context. And we'll see here that it's spending less time. It's kind of narrating to us a little bit less about what the form is because it already knows what that is. And it's not concerned with kind of bringing us that information back. It's going to give us a whole list of what it found to be checked, what the sketch shows. And here Claude is now becoming much more confident. With this additional context that we gave to Claude, Claude now feels it's appropriate to say vehicle B was at fault in this case based on this drawing and based on this sketch. So already we're seeing some improvement in the way Claude is analyzing these. I think we could probably all agree if we looked at the drawing and at the list that vehicle B is at fault. So we'd like to see that. So we're going to go back to the slides and talk about a couple of other items that we're not really using in this prompt, but can be really helpful to building up your prompt and making it work better. Exact. I think one thing that we really highlight is examples. I think examples or few shot is a mechanism that really is powerful in steering, Claude. So you can imagine this in quite a non-trivial way as well. So imagine you have scenarios, situations, even in this case, concrete accidents have happened that are tricky for Claude to get right. But do you, with your human intuition and your human label data, is able to actually get to your right conclusion? Then you can bake that information into the system prompt itself by having clear cut examples of A, the data that it's supposed to look at. So you can have visual examples. You can just base 64 encode an image and have that as part of the data that you're passing along into examples. And then on top of that, you can have the depiction or description rather of how to break that down and understand it. This is something we really highlight and emphasize in how you can push the limits of your LLM application is by baking in these examples into system prompt. And this again is the empirical science of prompt engineering that you always want to push the limits of your application and get a feedback loop in where it's going wrong and try to add that in system prompt. Next time, when example that sort of mimics that takes place, it's able to actually reference it in its example set. You can see here as well, this is just a little example of how we do this. Again, really emphasizing the sort of XML structure that we we enjoy, it gives a lot of structure to Claude. It's what it's been fine tuned on as well. And it works perfectly well for this example. And in our case, we're not doing this just because it's a simple demo. We can realistically imagine if you were building this for an insurance company, you'd have tens, maybe even hundreds of examples are quite difficult, maybe in the gray that you'd like to make sure that Claude actually has some basis in to make the verdict next time. Another topic we really want to highlight, which we're not doing in this demo is conversation history. It's in the same vein as examples. We use this to make sure that the enough context rich information is at close disposal when when when close working on your behalf. In our case, now this isn't really a user facing application. It's more something happening in the background. You can imagine for this insurance company, they have this automated system, some data is generated out of this and then you might have a human loop towards the end. If you were to build something much more user facing where you'd have a long conversation history that would be relevant to bring in, this is a perfect place in the system prompt include, because it enriches the context that Claude works within. In our case, we haven't done so. But what we do is and the next step is try to make sure we give a concrete reminder of the task at hand. So now we're going to build out the final part of this prompt for Claude. And that's coming back to the reminder of what the immediate task is and giving Claude a reminder about any important guidelines that we want it to follow. Sunt reasons that we may do this are a preventing hallucinations. So we want Claude to not invent details that it's not finding in this prompt or not finding in the data. If Claude can't tell which form is checked, we don't want Claude to take its best guess or invent the idea that a box might be checked when it's not. If the sketch is unintelligible, the person did a really bad job drawing this drawing and even a human would not be able to figure it out, we want Claude to be able to say that. And so these are some of the things we'll include in this final reminder and kind of wrap up step for Claude. Remind it to do things like answer only if it's very confident. We could even ask it to refer back to what it has seen in the form. Any time it's making a factual claim. So if it wants to say vehicle be turned right, it should say, I know this based on the fact that box two is clearly checked or whatever it might be. We can kind of give Claude some guidelines about that. So if we go back to the console, we can see the next version of the prompt. And we're going to keep everything the same here in the system prompts. We're not changing any of that background context. So we gave to Claude about the form, about how it's going to fill everything out. We're not changing anything else about the context and the role. We're just adding this detailed list of tasks. And this is how we want Claude to go about analyzing this. And a really key thing that we found here as we were building this demo. And when we were working on the customer example is that the order in which Claude analyzes this information is very important. And this is analogous to the way you might think about doing this. If you were a human, you would probably not look at the drawing first and try to understand what was going on. It's pretty unclear. It's a bunch of boxes and lines. We don't really know what that drawing is supposed to mean without any additional context. But if we have the form and we can read the form first and understand that we're talking about a car accident and that we're seeing some check boxes that indicate what vehicles were doing at certain times, then we know a little bit more about how to understand what might be in the drawing. And so that's the kind of detail that we're going to give Claude here is to say, hey, first go look at the form, look at it very carefully, make sure you can tell what boxes are checked, make sure you're not missing anything here, make a list for yourself of what you see in that and then move on to the sketch. So after you've kind of confidently gotten information out of the form and you can say what's factually true, then you can go on. And think about what you can gain from that sketch. Keeping in mind your understanding of the accident so far. So whatever you've learned from the form, you're trying to match that up with the sketch. And that's how you're going to arrive at your final assessment of the form. And we'll run it. And here you can see one behavior that this produced for Claude, because I told it to very carefully examine the form. It's showing me its work as it does that. So it's telling me each individual box is the box checked, is it not checked. And so this is one thing you'll notice as you do prompt engineering. In our previous prompts, we were kind of letting Claude decide how much it wanted to tell us about what it saw in the form here because I've told it carefully examine each and every box. It's very carefully examining each and every box. And that might not be what we want in the end. So that's something we might change. But it's also going to give me these other things that I asked for in XML tags. So a nice analysis of the form, the accident summary so far. It's going to give me a sketch analysis and it's going to continue to say that vehicle B appears to be clearly at fault. In this example, it's a pretty simple example with more complicated drawings, more less clarity in the forms. This kind of step-by-step thinking for Claude is really impactful in its ability to make a correct assessment here. So I think we'll go back to the slides and Christian's going to talk about a last kind of piece that we might add to this to really make it useful for a real world task. Indeed, thank you so much. So as Hannah mentioned, we sort of set the stage in this prompt to make sure that Claude's really acting on our behalf in the right manner. And a key step that we also add towards the end of this prompt, what I'm going to show you in a second, is a simple sort of guidelines or reminder part as well. So just strengthening and reinforcing exactly what we want to get out of it. And one important piece is actually output formatting. You can imagine if you're a data engineer working on this LLM application, all this sort of fancy preamble is great, but at the end of the day you want your piece of information to be stored in, let's say, your SQL database, wherever you want to store that data. And the rest of it that is necessary for Claude to sort of give its verdict isn't really that necessary for your application. You want the nitty-bitty information for your application. So if we transition back to the console, you'll see here that we just added a simple, important guidelines part. And again, this is just reinforcing the sort of mechanical behavior that we want out of Claude here. We want to make sure that the summary is clear, concise and accurate. We want to make sure that nothing is sort of impeding in Claude's assessment, apart from the data it's analyzing. And then finally, when it comes to output formatting, in my case here, I'm just going to ask Claude to wrap its final verdict, all other stuff I'm actually going to ignore from my application and just look at what it's actually assessing. And that is, I can use this if I want to build some sort of analytics tool off to this as well, or if I just want to clear cut determination, this is the way I can do so. So if I just run this here, you'll see it's going through the same sort of process that we've seen before, in this case it's much more succinct because we've asked it to be to summarize its findings in a much more straightforward manner. And then finally, towards the end, you'll see that it'll wrap my output in these final verdict XML tags. So you can see that during this demo, we've gone from a skiing accident to sort of unconfident insecure output from perhaps a car accident in the second version, to now a much more strictly formatted confident output that we can actually build and then let an application around. And actually help a real world car insurance company, for example. Finally, if we transition back to the slides, another key way of shaping closed output is actually putting words in closed mouth or as we call it pre filled responses. You could imagine that parsing XML tags is nice and all, but maybe you want a structured JSON output to make sure that it's JSON serializable and you can use this in a subsequent call, for example. This is quite simple to do. You could just add that Claude needs to begin its output with a certain format. This could be, for example, a open square bracket, squarely bracket, for example, or even in this case that we see in front of us, this would be an XML tag for itinerary. In our case, it could also be a final verdict XML tag. And this is just a great way of, again, shaping how Claude is supposed to respond without all the preamble if you don't want that, even though that is also key in shaping his output to make sure that Claude is reasoning through the steps that we wanted. So in our case here, we would just wrap it in the final verdict and then parse it afterwards, but you can use pre fill as well. Now, finally, one step that I would like to highlight here as well is that both Claude 3.7 and especially Claude 4, of course, is a hybrid reasoning model, meaning that there's extended thinking at your disposal. And this is something we want to highlight because you can use extended thinking as a crutch for your prompt engineering. Basically, you can enable this to make sure that Claude actually has time to think, it adds this thinking tags and the scratch pad. And the beauty of that is that you can actually analyze that transcript to understand how Claude is going about that data. So as we mentioned, we have these check boxes where it goes through step by step of the scenario that transpired for the accident. And in many ways there, you can actually try to help Claude in building this into the system prompt itself. It's not only more token efficient, but it's a good way of understanding how these intelligent models that don't have our intuition actually go about the data that we provide them. And because of that, it's quite key in actually trying to break down how your system prompt can get a lot better. And with that said, I think I'd like to thank all of you for coming today. We'll be around as well. So if you have any questions on prompting, please, please go ahead. I know there's a prompting. You want to learn more about prompting in an hour? We have prompting for agents. And right now we have an amazing demo of Claude plays Pokemon. So don't go anywhere for that. And as Christian said, we'll be around all day. So I know we don't have time for Q&A in this session. But please come find us if you want to chat. And thank you guys for coming. Thank you so much. diff --git a/memory/kb/index.json b/memory/kb/index.json index 351161f..9dfd406 100644 --- a/memory/kb/index.json +++ b/memory/kb/index.json @@ -1,5 +1,131 @@ { "notes": [ + { + "file": "notes-data/facebook/2026-05-26_500k-views-4-8k-reactions.md", + "title": "500K views · 4.8K reactions", + "date": "2026-05-26", + "tags": [], + "domains": [], + "types": [ + "coaching" + ], + "category": "facebook", + "project": null, + "subdir": null, + "video": "", + "tldr": "" + }, + { + "file": "notes-data/youtube/2026-05-25_claude-prompt-caching-token-saving.md", + "title": "Give Me 10 Mins and I'll Save You Millions of Claude Tokens", + "date": "2026-05-25", + "tags": [], + "domains": [ + "work", + "growth" + ], + "types": [], + "category": "youtube", + "project": null, + "subdir": null, + "video": "", + "tldr": "Prompt caching-ul din Claude Code salvează masiv din token-uri — autorul a salvat 91M tokeni într-o zi și 300M+ într-o săptămână. Tokenii cached costă 10% din prețul normal. TTL-ul cache-ului e 1 oră ..." + }, + { + "file": "notes-data/youtube/2026-05-21_anthropic-agent-harnesses-large-codebases.md", + "title": "Anthropic Just Dropped a Masterclass on Building Agent Harnesses (for Large Codebases)", + "date": "2026-05-21", + "tags": [ + "claude-code", + "ai-layer", + "coding-agents", + "codebase", + "productivity" + ], + "domains": [ + "work" + ], + "types": [], + "category": "youtube", + "project": null, + "subdir": null, + "video": "", + "tldr": "Anthropic a publicat un ghid despre cum să lucrezi cu Claude Code în codebaze mari. Mesajul central: **harness-ul (AI layer) contează la fel de mult ca modelul**. Videoul acoperă 7 componente ale \"AI ..." + }, + { + "file": "notes-data/youtube/2026-05-21_mircea-miclea-relatia-cu-banii.md", + "title": "BT Talks - Mircea Miclea, despre relația cu banii", + "date": "2026-05-21", + "tags": [], + "domains": [ + "growth", + "health", + "work" + ], + "types": [], + "category": "youtube", + "project": null, + "subdir": null, + "video": "", + "tldr": "Mircea Miclea (psiholog cognitiv, fondatorul școlii cognitive românești, UBB Cluj) explică de ce relația cu banii e preponderent emoțională și cum devenim mai raționali. Banii funcționează ca \"general..." + }, + { + "file": "notes-data/youtube/2026-05-21_hermes-agent-agentic-os.md", + "title": "Hermes Agent just got 10X Better (Agentic OS)", + "date": "2026-05-21", + "tags": [], + "domains": [ + "work", + "growth" + ], + "types": [ + "project" + ], + "category": "youtube", + "project": null, + "subdir": null, + "video": "", + "tldr": "Video prezintă cum să conectezi **Hermes** (agent AI mobil, 60K+ stars GitHub) cu **Claude Code** pentru un sistem de inteligenta AI unificat. Problema principala: Claude Code stie ce faci pe computer..." + }, + { + "file": "notes-data/youtube/2026-05-21_hermes-agent-personal-ai-assistant.md", + "title": "Hermes Agent: Zero to Personal AI Assistant (1 Hour Course)", + "date": "2026-05-21", + "tags": [], + "domains": [ + "work", + "growth" + ], + "types": [ + "project" + ], + "category": "youtube", + "project": null, + "subdir": null, + "video": "", + "tldr": "Hermes Agent este un proiect open-source (MIT, 140k+ GitHub stars) pentru asistent AI personal care rulează pe propria infrastructură. Se conectează via Telegram/Discord/WhatsApp, se îmbunătățește sin..." + }, + { + "file": "notes-data/youtube/2026-05-21_anthropic-claude-code-workflows-feature.md", + "title": "Anthropic Just Dropped the Update Everyone's Been Waiting For (Claude Code Workflows)", + "date": "2026-05-21", + "tags": [ + "claude-code", + "workflows", + "multi-agent", + "orchestration", + "productivity" + ], + "domains": [ + "work" + ], + "types": [], + "category": "youtube", + "project": null, + "subdir": null, + "video": "", + "tldr": "Claude Code a primit o funcție nouă (neoficial anunțată): **Workflows** — orchestrare deterministă multi-agent prin fișiere JavaScript. Rezolvă problema \"token tax\" și \"context bloat\" din abordarea cl..." + }, { "file": "notes-data/emails/2026-05-19_fwd-invitație-creative-paths-to-peace.md", "title": "Invitație - Creative Paths to Peace", @@ -9497,11 +9623,11 @@ } ], "stats": { - "total": 548, + "total": 555, "by_domain": { - "work": 176, - "health": 99, - "growth": 245, + "work": 182, + "health": 100, + "growth": 249, "sprijin": 39, "scout": 8 }, @@ -9511,14 +9637,14 @@ "conversations": 0, "emails": 22, "exercitii": 4, - "facebook": 6, + "facebook": 7, "health": 6, "insights": 46, "projects": 234, "reflectii": 3, "retete": 1, "tools": 7, - "youtube": 122, + "youtube": 128, "memory": 44 } }, diff --git a/memory/kb/youtube/2026-05-21_anthropic-agent-harnesses-large-codebases.md b/memory/kb/youtube/2026-05-21_anthropic-agent-harnesses-large-codebases.md new file mode 100644 index 0000000..e08d146 --- /dev/null +++ b/memory/kb/youtube/2026-05-21_anthropic-agent-harnesses-large-codebases.md @@ -0,0 +1,71 @@ +# Anthropic Just Dropped a Masterclass on Building Agent Harnesses (for Large Codebases) + +**Sursa:** https://youtu.be/efRIrLXoOVA?si=nygOxdoMyftTlKdN +**Data:** 2026-05-21 +**Durata:** 28:10 +**Tags:** @work #claude-code #ai-layer #coding-agents #codebase #productivity + +--- + +## TL;DR + +Anthropic a publicat un ghid despre cum să lucrezi cu Claude Code în codebaze mari. Mesajul central: **harness-ul (AI layer) contează la fel de mult ca modelul**. Videoul acoperă 7 componente ale "AI layer"-ului cu demo-uri practice și un plugin open-source pentru a le integra rapid în orice proiect. + +--- + +## Puncte cheie + +1. **AI Layer = a treia componentă a oricărui codebase** (după cod și teste): global rules, skills, hooks, LSP, MCP servers, sub-agents, plugins + +2. **Global rules: lean & layered** + - NU fă fișiere de mii de linii — studiile arată că diluează performanța agentului + - Folosește `CLAUDE.md` în subdirectoare: regulile se încarcă progresiv pe măsură ce navighezi + - Inițializează Claude Code direct din subdirectorul relevant → honing pe acea zonă + +3. **Hooks pentru self-improvement** + - **Stop hook**: rulează un subprocess Claude headless la final de sesiune → propune actualizări la `CLAUDE.md` bazate pe ce s-a schimbat + - **Start hook**: încarcă context dinamic (git status, documentație Confluence per echipă/rol) + - Asta face ca regulile să evolueze automat odată cu codul + +4. **Skills = workflows, nu reguli** + - `CLAUDE.md` = convenții; skills = procese reutilizabile + - Parametrul `path` permite scoparea unui skill la un subdirector specific → activare automată când lucrezi acolo + - Progressive disclosure: nu încarci totul, ci doar ce e relevant pentru task-ul curent + +5. **LSP + MCP = navigare de nivel IDE** + - LSP (Language Server Protocol) îi dă lui Claude aceleași capabilități de navigare pe care le ai în VS Code (go to definition, find references) + - Înlocuiește/completeaza `grep` cu căutări semantice la nivel de simbol + - Esențial pentru codebaze 100k+ linii unde grep devine lent și token-ineficient + +6. **Sub-agents: separă explorarea de editare** + - Trimite explorarea (research web, analiză codebase) la sub-agent cu propriul context window + - Primești doar summary-ul înapoi → context window principal rămâne curat + - Claude Code are deja Explorer sub-agent built-in + +7. **Ownership organizational** + - Desemnează 1-2 persoane să construiască AI layer-ul standard pentru echipă + - "Quiet investment period" → buildout → rollout → adoptare consistentă + - Evită: oameni dezamăgiți la primul contact (fără AI layer) și fragmentare (fiecare cu AI layer propriu) + +--- + +## Quote-uri + +> "The harness matters as much as the model. A lot of people get hyperfixated on model benchmarks... But honestly, what matters even more is the ecosystem built around the model." + +> "Global rules are your conventions. Your skills are the workflows." + +> "Not all expertise needs to be present in every session — same reason why we have different CLAUDE.md files in subdirectories." + +> "Use sub-agents to split exploration from editing. By the time we get to the actual editing, we're already going to have this extremely bloated context window." + +--- + +## Idei aplicabile direct pentru Echo Core / roa2web + +- [ ] **Subdirectory CLAUDE.md** pentru `src/adapters/`, `dashboard/`, `tools/` — reguli specifice per zonă @work +- [ ] **Stop hook self-improving** — subprocess Claude la final de sesiune care propune update-uri la `personality/*.md` sau `CLAUDE.md` @work +- [ ] **Start hook** — încarcă automat git status + ultimele commits la pornire sesiune @work +- [ ] **Skill path-scoped** — ex: skill "adaugă handler dashboard" scoped la `dashboard/handlers/` @work +- [ ] **MCP search îmbunătățit** — dacă roa2web crește mult, LSP MCP pentru navigare mai bună @work + diff --git a/memory/kb/youtube/2026-05-21_anthropic-claude-code-workflows-feature.md b/memory/kb/youtube/2026-05-21_anthropic-claude-code-workflows-feature.md new file mode 100644 index 0000000..db1ee30 --- /dev/null +++ b/memory/kb/youtube/2026-05-21_anthropic-claude-code-workflows-feature.md @@ -0,0 +1,131 @@ +# Anthropic Just Dropped the Update Everyone's Been Waiting For (Claude Code Workflows) + +**Sursa:** https://youtu.be/c0gVowvMR-g?si=V88cMDg4GGrkXWIZ +**Data:** 2026-05-21 +**Durata:** 15:10 +**Tags:** @work #claude-code #workflows #multi-agent #orchestration #productivity + +--- + +## TL;DR + +Claude Code a primit o funcție nouă (neoficial anunțată): **Workflows** — orchestrare deterministă multi-agent prin fișiere JavaScript. Rezolvă problema "token tax" și "context bloat" din abordarea clasică cu orchestrator LLM. Activare: `CLAUDE_CODE_WORKFLOWS=1 claude` + +--- + +## Problema pe care o rezolvă + +**Abordarea veche (orchestrator LLM):** +- Sub-agent execută task → rezultat intră în context window principal → se pasează la sub-agentul următor +- Token tax: rezultatele circulă inutil prin orchestrator (nu direct agent→agent) +- Orchestratorul devine din ce în ce mai "sloppy" pe măsură ce contextul se umple +- Conditionale devin unreliable (orchestratorul "uită") +- Zero vizibilitate în timp real la ce se întâmplă + +**Soluția Workflows:** +- Orchestratorul NU mai e un model — e **cod JavaScript** +- Rezultatele se pasează direct agent→agent, fără a intra în contextul principal +- Poți rula 20-30-100 sub-agenți fără să crești contextul orchestratorului +- Retry automat per sub-agent (3 retries) +- Vizibilitate completă: `/workflows` în CLI, live progress, poți pause/resume + +--- + +## Cum funcționează + +**Activare:** +```bash +CLAUDE_CODE_WORKFLOWS=1 claude +``` + +**Structura fișierului:** `.claude/workflows/.js` + +```javascript +// META +export const meta = { + name: "Triage Sentry Issues", + description: "...", + phases: ["load", "fix", "verify"] +}; + +// SCHEMA (output structurat per agent) +const issuesSchema = { issue_id, title, user_count }; +const verdictSchema = { fixed, notes }; + +// ARGUMENTE (cu default) +const { minUsers = 20 } = args; + +// FAZE +const issues = await agent({ + prompt: "Use Sentry MCP to list unresolved issues...", + schema: issuesSchema +}); + +// JavaScript pur pentru filtrare/conditionale +const bigIssues = issues.filter(i => i.user_count > minUsers); +if (bigIssues.length === 0) return { fixed: "No issues above threshold" }; + +// PIPELINE (streaming: următorul stage pornește imediat, nu așteaptă batch) +await pipeline(bigIssues, [ + async (issue) => agent({ prompt: `Fix issue ${issue.id}: ${issue.title}` }), + async (fix) => agent({ prompt: `Verify fix for ${fix.issue_id}` }) +]); +``` + +--- + +## Toolkit disponibil + +| Primitiv | Descriere | +|----------|-----------| +| `agent({})` | Un sub-agent nou (fresh context) per apel | +| `parallel([])` | Batch de agenți în paralel, așteaptă toți | +| `pipeline(items, stages)` | Streaming: stage următor pornește imediat când un item finalizează | +| `schema` | Returnează output structurat (JSON) dintr-un agent | +| `phaseLog(msg)` | Log vizibil live în CLI | +| `args` | Argumente pasate la pornire | +| `budgetRemaining` | Tokens rămași — pentru while loops cu buget | + +**Budget control:** +```javascript +while (budgetRemaining > 50_000) { + await agent({ prompt: "Find and fix one bug..." }); +} +``` + +--- + +## Exemple de use cases + +1. **Triage Sentry** — încarcă issues, filtrează după user count, fix + verify în paralel +2. **Dead code sweep** — loop de 8 runde: find unused → remove → repeat până nu mai găsește +3. **Personalized outreach** — încarcă leads CSV → research cu model ieftin (fallback scump dacă nu găsește) → draft mesaje personalizate → salvează output +4. **Issue backlog loop** — preia issues GitHub, fix + review adversarial + move on (echivalent Ralph loop, dar deterministic) + +--- + +## Când să folosești workflow vs. task ad-hoc + +**Workflow:** task repetabil (faci zilnic), fan-out pe conditionale/loops, task lung care poate eșua pe la mijloc (auto-resumable) + +**Ad-hoc (claude normal):** task one-off, nu merită overhead-ul unui fișier JS + +--- + +## Quote-uri + +> "Instead of a model passing information back and forth between sub-agents and incurring a token tax every single time... what if we just had a workflow file, some kind of code?" + +> "The orchestrator is now code instead." + +> "I would suggest getting Claude Code to look through your previous sessions, identify any opportunities for making workflows and make workflows around them." + +--- + +## Idei aplicabile pentru Echo Core / Ralph + +- [ ] **Ralph ca Workflow** — înlocuiește `ralph.sh` bash loop cu un workflow Claude nativ: load stories din `prd.json` → pipeline(stories, [implement, review, verify]) @work +- [ ] **Triage workflow** — heartbeat care procesează emails/calendar poate deveni workflow: load → categorize → act per categorie @work +- [ ] **dead-code-sweep workflow** — util pentru curățenie periodică în `dashboard/handlers/` @work +- [ ] Skill `workflow-creator` descărcat din GitHub-ul autorului pentru a genera automat fișiere workflow @work + diff --git a/memory/kb/youtube/2026-05-21_hermes-agent-agentic-os.md b/memory/kb/youtube/2026-05-21_hermes-agent-agentic-os.md new file mode 100644 index 0000000..7daf5dd --- /dev/null +++ b/memory/kb/youtube/2026-05-21_hermes-agent-agentic-os.md @@ -0,0 +1,69 @@ +# Hermes Agent just got 10X Better (Agentic OS) + +**URL:** https://youtu.be/7xuWZ-3lyQE +**Autor:** Jack (built & sold tech startup) +**Durata:** 31:08 +**Data:** 2026-05-21 +**Tags:** @work @growth @project + +--- + +## TL;DR + +Video prezintă cum să conectezi **Hermes** (agent AI mobil, 60K+ stars GitHub) cu **Claude Code** pentru un sistem de inteligenta AI unificat. Problema principala: Claude Code stie ce faci pe computer, Hermes stie conversatiile de pe Telegram — nu exista context shared intre ele. Solutia = "Claude OS Bridge" care permite Hermes sa citeasca chat logs + memory din Claude Code si vice versa. Demo include: setup Hermes pe Telegram, sistem de personas (Pantheon), conectare Obsidian, Apollo API pentru B2B lead gen, Zapier MCP pentru Gmail/Calendar. + +--- + +## Puncte cheie + +1. **Problema core:** Niciun handshake intre AI-ul de pe computer (Claude Code) si AI-ul de pe telefon (Hermes). Pierzi context la fiecare tranzitie — ideea trimisa pe Telegram nu ajunge niciodata in Claude Code. + +2. **Claude OS Bridge:** Hermes citeste dashboard-ul Claude Code (chat logs, model usage, memory systems) si vice versa. Rezultat: context unificat peste tot. + +3. **Pantheon (personas pe modele diferite):** Asignezi modele specifice la roluri — DeepSeek/gratuit pentru research nocturn, GPT 5.5 pentru morning brief, Opus pentru taskuri complexe. Nu risipesti modelele scumpe pe taskuri simple. + +4. **Setup Hermes:** Un singur command in terminal, configurare via Telegram BotFather. Whitelist user ID pentru securitate. Optional rulat ca serviciu. + +5. **Mirror in GitHub privat:** Backup + versioning pentru configs si personas. Cron la 23:00 pentru sync automat. Rollback la orice versiune daca ceva se strica. + +6. **Obsidian integration:** Conectezi vault-ul Obsidian la Hermes — memorie structurata, vizualizabila, cu graph view. + +7. **Apollo API pentru B2B lead gen:** Din Telegram poti cere Hermes sa gaseasca 20 companii dintr-o nisa+locatie si sa draftuiasca emails. Delta mica intre idee si actiune. + +8. **Zapier MCP pentru Gmail/Calendar:** Conectare simpla, principiul "least access" — draft only, nu send. Calendar: create/delete events OK, send emails NO. + +9. **Cron jobs overnight:** Morning brief + sugestii de imbunatatire bazate pe toate conversatiile din toate AI-urile de pe computer. + +--- + +## Quote-uri + +> "Hermes hears it, Claude Code knows it, and vice versa — you have a universal AI intelligence system." + +> "The delta between idea and action should be small." + +> "We don't need Albert Einstein to mop our floors." — despre alegerea modelului potrivit pentru fiecare task + +> "Never give it the ability to send emails, only to draft. Follow the principle of least access." + +> "It is an agent that dreams, that thinks, that self-improves." + +--- + +## Relevanta pentru Echo Core + +Sistemul descris e practic ce face deja Echo Core, dar din directia opusa (Hermes citeste Claude Code, Echo Core este Claude Code + adaptoare). Idei aplicabile: + +- **Pantheon concept** — personas diferite per task cu modele diferite (deja partial implementat cu model selection in AGENTS.md) +- **OS Bridge bidirectional** — a da contextul complet agentului mobil; relevant pentru heartbeat + memory search +- **Apollo API** — pentru "mai multi clienti" (durere cunoscuta a lui Marius); lead gen B2B din Telegram fara desktop +- **Least access principle** — deja respectat in AGENTS.md pentru email/calendar +- **GitHub mirror** — backup config + personality/*.md intr-un repo privat cu cron sync + +--- + +## Linkuri mentionate + +- Hermes: https://hermes.sh (sau similar — din video) +- Apollo API: https://developer.apollo.io +- Zapier MCP: https://zapier.com/mcp diff --git a/memory/kb/youtube/2026-05-21_hermes-agent-personal-ai-assistant.md b/memory/kb/youtube/2026-05-21_hermes-agent-personal-ai-assistant.md new file mode 100644 index 0000000..2d5dc00 --- /dev/null +++ b/memory/kb/youtube/2026-05-21_hermes-agent-personal-ai-assistant.md @@ -0,0 +1,78 @@ +# Hermes Agent: Zero to Personal AI Assistant (1 Hour Course) + +**Sursă:** https://youtu.be/gb5TlGw6Uks +**Canal:** Nate Herk +**Durată:** 58:22 +**Data:** 2026-05-21 +**Tags:** @work @growth @project + +--- + +## TL;DR + +Hermes Agent este un proiect open-source (MIT, 140k+ GitHub stars) pentru asistent AI personal care rulează pe propria infrastructură. Se conectează via Telegram/Discord/WhatsApp, se îmbunătățește singur prin skills și memorie, și suportă cron jobs în limbaj natural. Creatorul îl folosește complementar cu Claude Code: CC pentru muncă la birou/coding, Hermes pentru task-uri din mers (pe telefon, în Telegram). Video-ul e un tutorial complet setup pe VPS cu Docker + Telegram + backup GitHub automat. + +--- + +## Puncte cheie + +**Ce e Hermes Agent:** +- Open source, MIT, rulează pe orice VPS/Mac mini/Docker/Android (Termux) +- Self-improving: scrie și actualizează singur skills-uri din conversații +- 91 skills built-in din start, 520+ comunitate disponibile +- Interfețe: Telegram, Discord, WhatsApp, iMessage, CLI terminal + +**Comparație Claude Code vs OpenClaw vs Hermes:** +- **Claude Code** = daily driver pentru coding, knowledge work la birou — 90% din munca grea +- **OpenClaw** = mai mare echipă, 350k stars, enterprise (Nvidia NeMo Claw), mai frequent updates dar uneori instabil +- **Hermes** = mai ușor, mai stabil, pe-go, focus pe self-improvement, bun cu modele open-source +- Nu se exclud — se folosesc împreună: CC pentru coding, Hermes pentru automatizări din mers + +**Cei 5 piloni ai Hermes:** + +1. **Memory** — `user.md` (cine ești, preferințe) + `memory.md` (proiecte, context business); se încarcă la fiecare sesiune; agentul actualizează automat +2. **Skills** — "rețete" procedurale în fișiere `.md` cu YAML front matter; progressive disclosure (nu încarcă tot contextul); se creează/actualizează automat din conversații +3. **Soul** — `soul.md` definește personalitatea agentului; se evoluează din feedback +4. **Crons** — task-uri programate în limbaj natural ("în fiecare zi la 6am fă X"); sesiuni izolate, nu moștenesc contextul curent; NU pot crea alte cron-uri recursiv +5. **Self-improving loop** — muncă → memorie/skills → căutare sesiuni vechi → înapoi la muncă + +**Setup practic:** +- VPS recomandat: Hostinger, KVM2+ (~100$/an); one-click Docker deploy pentru Hermes +- Inference: OpenAI Codex (ChatGPT subscription 20$/lună, fără API keys) +- API keys NICIODATĂ în chat — `hermes config set CHEIE valoare` direct în container +- GitHub backup: skill "nightly GitHub sync" creat din conversație naturală, cron la miezul nopții + +**Best practices:** +- Fiecare agent → propriul container Docker cu chei separate (least privilege) +- Cloud Code project separat pentru a gestiona VPS-urile (IP, parole, env vars) +- Când agentul greșește de 2 ori → corectează pe loc + cere actualizare skill/memorie +- Fișier `memory.md` stale = cauza #1 de comportament ciudat +- Agenți separați când: memorie diferită, chei diferite, audiență diferită, task-uri continue + +**CLI vs Telegram:** +- CLI = cockpit (control complet, slash commands, vizibilitate context window, ideal coding) +- Telegram = telecomandă (task-uri rapide, crons, din mers, mai puțin vizibil context) +- Același agent, aceleași skills/memorie, dar Telegram e mai opac la compaction/sesiuni + +--- + +## Quote-uri relevante + +> "Hermes doesn't replace Claude Code for me, but it's kind of my on-the-go spin up things really quick." + +> "Think about what are your coding agents actually working in — they're working in some sort of directory. If you have a GitHub repo of all of your knowledge, you can pick out any of these agents and just plop it on top." + +> "Automatic does not mean magic. The loop works best when the user corrects Hermes, asks it to save things to memory, and lets it create and update skills after complex work." + +> "Pretend this is an actual intern or a new employee. What access would you give them? You wouldn't just give them your credit card." + +> "This isn't a tool you finish setting up, it's a teammate that you keep using and you keep training." + +--- + +## Idei acționabile + +- [ ] @growth Hermes Agent ca alternativă la Echo Core pentru task-uri din mers — arhitectura similară cu ce facem deja (skills = personality md, crons = jobs.json, memory = memory/) +- [ ] @work Ideea de "Claude Code project" per VPS/agent pentru management organizat — aplicabil la gestionarea infrastructurii Proxmox +- [ ] @work Backup automat GitHub prin cron (noapte) — similar cu ce avem deja, dar skill refolosibil +- [ ] @work Skills hub Hermes (520+ comunitate) — merită explorat pentru idei de automatizări noi diff --git a/memory/kb/youtube/2026-05-21_mircea-miclea-relatia-cu-banii.md b/memory/kb/youtube/2026-05-21_mircea-miclea-relatia-cu-banii.md new file mode 100644 index 0000000..18d53a0 --- /dev/null +++ b/memory/kb/youtube/2026-05-21_mircea-miclea-relatia-cu-banii.md @@ -0,0 +1,72 @@ +# BT Talks - Mircea Miclea, despre relația cu banii + +**Sursa:** https://www.youtube.com/watch?v=4DV6Iq91NJg +**Data:** 2026-05-21 +**Durata:** 48:17 +**Tags:** @growth @health @work + +--- + +## TL;DR + +Mircea Miclea (psiholog cognitiv, fondatorul școlii cognitive românești, UBB Cluj) explică de ce relația cu banii e preponderent emoțională și cum devenim mai raționali. Banii funcționează ca "general reinforcer" — se convertesc în orice recompensă, generând fantasme puternice. Soluția finală: gestionează banii în funcție de proiectul personal și etica ta, nu în funcție de emoțiile momentului. + +--- + +## Puncte cheie + +**1. Banii = convertor universal** +Spre deosebire de orice altă recompensă, banii se pot converti în n alte recompense. Asta creează "emotional forecasting" — ne imaginăm emoții viitoare și luăm decizii prezente bazate pe fantasme. Frica și lăcomia la burse sunt exact asta. + +**2. Românii și aversiunea la risc** +Nu e specifică românilor față de alte națiuni, dar europenii sunt mai aversivi la risc decât americanii (sondaj Gallup: falimentul ca experiență de învățare). Cauzele: secole de sărăcie, acces limitat la bani → fie tezaurizare compulsivă, fie cheltuiala compulsivă (să "arăți că ai scăpat de condiție"). Europa reglementează, America inovează. + +**3. Mintea = palimsest** +Experiențele din copilărie nu te marchează pentru totdeauna. Pot fi suprascrise cu experiențe noi. Responsabilitatea noastră ca adulți: ce facem cu ce a făcut viața din noi. "Nu avem nicio scuză să facem din prezentul și viitorul nostru o notă de subsol la trecutul nostru." + +**4. Incertitudine — soluția: vectori** +3 tipuri de incertitudine: epistemică (nu știu ce e), predictivă (nu știu cum va evolua), acțională (nu știu ce să fac). Soluție practică: stabilește ce vei face — un proiect concret. "Fii râu, nu baltă." Oamenii cu vectori traversează incertitudinea mult mai ușor. + +**5. Capcane mentale** + +- **Utilitate subiectivă vs valoare obiectivă:** Creierul raportează valoarea la un referențial. 100 RON când ai 0 = enorm. 100 RON când ai 10.000 = jignitor. Aceeași sumă, utilitate total diferită. +- **Aversiunea la pierdere:** Pierderile dor mai mult decât câștigurile bucură. Filogenetic adaptiv, dar ne face să tezaurizăm în loc să investim. Agassi: "Mă enervează mai mult când pierd decât mă bucur când câștig." +- **Sunk cost effect:** Luăm decizii bazate pe cât am investit deja, nu pe consecințele viitoare. Capcana: continui o relație/afacere proastă pentru că "am investit atât". Decizia corectă: ignoră trecutul, evaluează doar consecințele prezente și viitoare. + +**6. Cheltuiala compulsivă vs economisire compulsivă** +Ambele vin din anxietate/nesiguranță. Economisirea = "flight" (evit pierderea). Cheltuiala compulsivă = iluzia că ești "în control" sau hedonism pentru a face stresul suportabil (spike de dopamină). + +**7. Educație financiară** +- Vârsta optimă: 12-14 ani (centrii de plăcere > cortex prefrontal) +- NU prin profesori și manuale — prin oameni din realitate care vin la ore +- Părinții: esențiali — arată relația muncă-recompensă, nu recompense gratuite + +--- + +## Citate memorabile + +> "Emoțiile sunt supremul bine și supremul rău." + +> "Doamne, să nu mă faci atât de bogat ca să devin mândru, dar nici atât de sărac ca să devin ticălos." — Isus Sirah (Biblie) + +> "Bate fierul cât e rece." — inversul zicalei, despre a lua decizii financiare după ce emoțiile s-au liniștit + +> "Fii râu, nu baltă." — despre a avea un vector, o direcție clară + +> "Nu contează atât de mult ce face istoria din om. Contează mai degrabă ce face omul din ce a făcut istoria din el." — parafrazare Jean-Paul Sartre + +> "Nu avem niciun fel de scuză să facem din prezentul și viitorul nostru un fel de notă de subsol la trecutul nostru." + +--- + +## Sfatul final (esența) + +> "Înainte de a te gândi la bani, gândește-te la proiectul tău personal și la etica ta personală. Gestionează banii în funcție de un proiect și de propria ta etică." + +--- + +## Conexiuni relevante + +- **Inacțiune antreprenorială:** Aversiunea la pierdere + sunk cost pot explica blocajul — "clienti noi = mai multă muncă" e o fantasmă negativă bazată pe un referențial trecut +- **Coaching NLP:** Mintea = palimsest e echivalentul cu rescriere de ancore/credinte — direct aplicabil +- **Incertitudine și proiecte:** Vectorii ca antidot — exact ce lipsește când stai "în baltă" diff --git a/memory/kb/youtube/2026-05-25_claude-prompt-caching-token-saving.md b/memory/kb/youtube/2026-05-25_claude-prompt-caching-token-saving.md new file mode 100644 index 0000000..c21a374 --- /dev/null +++ b/memory/kb/youtube/2026-05-25_claude-prompt-caching-token-saving.md @@ -0,0 +1,56 @@ +# Give Me 10 Mins and I'll Save You Millions of Claude Tokens + +**URL:** https://youtu.be/6cEQEba0i2A +**Data:** 2026-05-25 +**Durata:** 10:43 +**Tags:** @work @growth @claude-code @prompt-caching @tokens + +--- + +## TL;DR + +Prompt caching-ul din Claude Code salvează masiv din token-uri — autorul a salvat 91M tokeni într-o zi și 300M+ într-o săptămână. Tokenii cached costă 10% din prețul normal. TTL-ul cache-ului e 1 oră pe subscripție, 5 minute pe API. 3 obiceiuri simple acoperă 95% din cazuri. + +--- + +## Puncte cheie + +- **Tokenii cached = 10% din cost** — cei care se recachează sunt de 10x mai ieftini +- **TTL 1 oră** pe subscripție Claude Code (în terminal/extensie). Dacă nu apeșzi nimic timp de 1 oră, tot se recachează +- **TTL 5 minute** pe API și sub-agenți (pe orice plan) — periculos dacă ai sesiuni multiple +- **Ce se cachează automat:** + - System instructions + tool definitions (global) + - CLAUDE.md + memory/rules (per proiect) + - Conversația (grow per turn, re-cached la fiecare mesaj) +- **Ce rupe cache-ul:** + - Pauza >1 oră + - Schimbarea modelului (chiar și `model opus plan` — schimbă model în plan mode → sonnet în exec → **rupe cache-ul**) + - Schimbarea system prompt-ului (CLAUDE.md editabil mid-session, dar se aplică doar la restart — cache rămâne intact!) +- **`model opus plan` are un trade-off ascuns:** deși economisește tokeni pe termen lung, fiecare toggle plan mode = switch model = fresh cache +- **3 obiceiuri pentru 95% din cazuri:** + 1. Nu lăsa sesiunea idle >1 oră — handoff la sesiune nouă + 2. La schimbare de task: `/compact` sau `/clear` + session handoff skill + 3. Dacă pui documente mari în Claude.ai chat — mai bine Projects (caching mai bun) +- **Session handoff skill** (gratuit în comunitate): rezumă tot, fișiere importante, decizii deschise → `/copy` → `/clear` → paste → continuă fără pierderi +- **Token dashboard** (GitHub, gratuit): vizualizează cache_create vs cache_read pe zile/sesiuni, citește fișierele locale existente + +--- + +## Quote-uri + +> "Cached tokens only cost you 10% of normal input. So, all the tokens that are getting cached are saving you a ton of money." + +> "If you leave a session sitting for an hour or longer, then you're going to pay more for it." + +> "We actually run alerts on our prompt cache hit rate and declare SEVs if they're too low." — Thoric (Anthropic) + +> "The Opus plan model setting resolves to Opus during plan mode and Sonnet during execution. So, each plan toggle is a model switch and starts a fresh cache." + +--- + +## Idei acționabile + +- [ ] Verifică dacă Echo Core folosește `model opus plan` — dacă da, evaluat trade-off vs caching +- [ ] Session handoff: skill util pentru sesiuni lungi Claude Code (alternativă la /compact) +- [ ] Nu edita CLAUDE.md și așteptă restart imediat — cache-ul rămâne intact până la restart +- [ ] Sub-agenții (Ralph!) au TTL 5 min pe API — ține cont la rulările nocturne diff --git a/tasks/lessons.md b/tasks/lessons.md index 6cd5ae6..bf5f24d 100644 --- a/tasks/lessons.md +++ b/tasks/lessons.md @@ -17,6 +17,13 @@ Lecții capturate din corectările lui Marius. Citește acest fișier la începu +## Nu șterge crontab-uri din sistem fără confirmare explicită +**Data:** 2026-05-20 +**Context:** Marius a cerut să șteargă "newsletter test din cron jobs". Am interpretat că `check_newsletter_cercetasi.py` din crontab de sistem face parte din "newsletter test". +**Greșeala:** Am inclus în scop un crontab de sistem care nu fusese menționat explicit. "newsletter test" se referea doar la job-ul `newsletter-test` din `cron/jobs.json`. +**Regula:** Crontab-ul de sistem (`crontab -l`) este separat de `cron/jobs.json`. Nu îl modifica fără instrucțiuni explicite. Dacă scope-ul nu e clar, întreabă înainte de a acționa pe crontab sistem. +**Când se aplică:** Orice task care implică ștergerea sau modificarea cron jobs — distinge întotdeauna între `cron/jobs.json` (APScheduler) și crontab-ul de sistem. + ## Nu scrie manual în index.json — rulează update_notes_index.py **Data:** 2026-04-29 **Context:** Salvam o notiță din Facebook reel în memory/kb/. Am adăugat manual o intrare în index.json cu schema greșită (`id` + `path` în loc de `file`), ceea ce a blocat notes.html pe "Se încarcă..." cu un TypeError în renderNoteCard. diff --git a/tools/anaf-monitor/hashes.json b/tools/anaf-monitor/hashes.json index 48921a3..c189ee1 100644 --- a/tools/anaf-monitor/hashes.json +++ b/tools/anaf-monitor/hashes.json @@ -1,5 +1,5 @@ { - "D100": "991bb91d158f09de5bf661e3060f8568f9ee0df0cb9db69bd119ba7a0d95048a", + "D100": "126ebae8fc65d7ae19c9fe14e755c6421152aac16b19abf7fafeaa34aa87cafe", "D101": "f72fc1c29657ea11e0238806a28f6abccf5b00e45904e1e0c9385cc64491fcaf", "D300": "cb7b55b568ab893024884971eac0367fb6fe487c297e355d64258dae437f6ddd", "D394": "c4c4e62bda30032f12c17edf9a5087b6173a350ccb1fd750158978b3bd0acb7d", diff --git a/tools/anaf-monitor/snapshots/D100.txt b/tools/anaf-monitor/snapshots/D100.txt index 555cbfc..84cb45d 100644 --- a/tools/anaf-monitor/snapshots/D100.txt +++ b/tools/anaf-monitor/snapshots/D100.txt @@ -62,10 +62,10 @@ valabil începand cu 01/2024 - publicat în data de 09.02.2024 soft A actualizat în data de -20.05.2026 +22.05.2026 soft J* actualizat în data de -20.05.2026 +25.05.2026 Anexa validări actualizat în data de diff --git a/tools/anaf-monitor/versions.json b/tools/anaf-monitor/versions.json index b8b0e17..5a1fd49 100644 --- a/tools/anaf-monitor/versions.json +++ b/tools/anaf-monitor/versions.json @@ -1,9 +1,9 @@ { "D100": { - "soft_a_url": "http://static.anaf.ro/static/10/Anaf/Declaratii_R/AplicatiiDec/D100_710_XML_0126_200526.pdf", - "soft_a_date": "20.05.2026", - "soft_j_url": "http://static.anaf.ro/static/10/Anaf/Declaratii_R/AplicatiiDec/D100_20052026.zip", - "soft_j_date": "20.05.2026" + "soft_a_url": "http://static.anaf.ro/static/10/Anaf/Declaratii_R/AplicatiiDec/D100_710_XML_0126_220526.pdf", + "soft_a_date": "22.05.2026", + "soft_j_url": "http://static.anaf.ro/static/10/Anaf/Declaratii_R/AplicatiiDec/D100_22052026.zip", + "soft_j_date": "22.05.2026" }, "D101": { "soft_a_url": "https://static.anaf.ro/static/10/Anaf/Declaratii_R/AplicatiiDec/D101_XML_2025_180326.pdf",