DEV Community: Ricards Taujenis

CLAUDE.md & Rules - Before Skills, Hooks, or Agents

Ricards Taujenis — Mon, 22 Jun 2026 07:19:10 +0000

If you're using Claude Code with open-ended prompts and re-explaining your project every session, you're quietly burning through your Pro usage for nothing. CLAUDE.md and Rules fix that — and they're the foundation everything else (Skills, Hooks, Agents) gets built on top of.

This is part 1 of a 5-part series walking through Claude Code's features in order — CLAUDE.md and Rules first, then Hooks, Skills, MCP, and Subagents, all using the same real project as the example.

The Problem With Open-Ended Prompts

Every time you open a fresh Claude Code session without context, you're paying twice. Once to re-explain your architecture, your conventions, your stack — and again when Claude inevitably guesses wrong on something you already told it last week.

This is the part that's easy to underestimate. It's not just wasted tokens — it's wasted attention. Every paragraph you spend re-establishing "this project uses DDD, Redis is for hot data, Airtable is for history" is a paragraph that isn't moving the actual task forward. Multiply that across every session, every week, and the cost adds up fast — especially on a Pro plan where usage isn't infinite.

Without a persistent source of truth, you're not building a relationship with your codebase. You're starting from zero, every single time. The fix isn't a better prompt. It's not needing to write that prompt at all.

Planning First: Sketching the Rules Before Touching the Repo

Before writing anything into the actual repository, the first real step happened in the Claude Desktop app — not Claude Code. This is worth calling out because it's a genuinely useful pattern, not just a detour.

The idea was simple: rather than improvising a CLAUDE.md prompt cold inside the project, sketch it out in a separate chat first. That conversation surfaced a few specific questions that needed answers before any rule could be written correctly:

What does the project use for the backend/API layer? (Go)
How should Trading212 data get pulled in? (the public API, if available)
What actually triggers the weekly Redis → Airtable migration? (a Fly.io scheduled cron machine)

These aren't trivial details. They directly shape what the rules say — "store snapshots in Redis" is a vague rule, but "move data older than 7 days from Redis into Airtable via a weekly Fly.io cron job, then purge it from Redis" is a rule Claude can actually enforce and verify against.

What CLAUDE.md + Rules Actually Do

CLAUDE.md and .claude/rules/ solve two different problems:

CLAUDE.md — the big picture. Project overview, tech stack, architecture, dependency direction. This is what Claude reads to understand what the project is.
.claude/rules/ — the enforceable specifics. Coding standards, layer boundaries, naming conventions. This is what Claude reads to understand how to write code for it. The split matters more than it looks. CLAUDE.md is narrative — it reads like documentation, and it's the kind of thing a new human teammate would also want to read. Rules are closer to a linter's config file: terse, specific, and meant to be checked against rather than just read once and absorbed.

Notice the split: .claude/rules/portfolio.md holds the enforceable rules, CLAUDE.md holds the narrative context, and .claudeignore keeps Claude away from .env and other files it has no business touching. The folder structure also shows the DDD layering — domain/, infrastructure/, application/, cmd/, config/ — sitting right alongside the .claude/ directory, which is intentional. The rules aren't bolted on after the fact; they describe the structure that's already there.

The Real Test: Fixing an API Issue

The actual proof a rules-based setup works isn't the first prompt — it's the second one. When an API issue came up mid-build, the fix wasn't to re-explain the whole project again. It was a one-line edit to the rules file itself.

Claude Code was authenticating against Trading212 the wrong way — guessing at a bearer token approach that returned a 401. The fix wasn't a back-and-forth conversation explaining the API again. It was adding a dedicated section to the rules file:

## Trading212 API

- Official docs: https://docs.trading212.com/api
- Base URL: `https://live.trading212.com/api/v0`
- Authentication: HTTP Basic Auth — `Authorization: Basic base64(accessKey:secretKey)`.
  - `TRADING_212_STORAGE_ACCESS_KEY` is the access key (username)
  - `TRADING_212_SECRET_STORAGE_ACCESS_KEY` is the secret key (password)
- Do NOT use a plain bearer token or `Authorization: Bearer` — that is the deprecated approach and returns 401.
- Portfolio positions endpoint: `GET /equity/portfolio`
- Always consult https://docs.trading212.com/api before adding new Trading212 endpoints.

With the official docs link and the correct auth scheme written into the rule, Claude Code referenced the right context immediately and fixed the issue — no re-explaining, no trial and error on a second guess. The rule didn't just patch the bug once; it makes the same mistake structurally impossible to repeat in any future session, because the correct auth method and a link to verify it are now sitting right there in the rules file.

That's the actual payoff. When something breaks — an API quirk, a naming mismatch, a layer violation — the fix is a targeted edit to the rule that's wrong or missing, not a fresh paragraph of context typed into a new prompt. The next session, and every session after that, inherits the fix for free.

Try It Yourself

Repo: github.com/Mozes721/PortfolioPulse
Video: youtu.be/4BmACot5BF0
Claude Code best practices: code.claude.com/docs/en/best-practices Clone the repo, open .claude/rules/portfolio.md, and adapt it to your own stack. The structure transfers even if your project has nothing to do with stocks or Redis. If you want to try the planning-first approach, sketch your own project's data flow in a Claude Desktop or claude.ai chat before writing a single file — the few minutes spent clarifying triggers, sources, and storage boundaries pays off the moment Claude has to write code against them.

What's Next

CLAUDE.md and Rules are the foundation. Next up: Hooks — automating lint fixes, format-on-save, and deploy triggers so Claude isn't just following rules, it's reacting to events in your workflow automatically.

Subscribe or follow along if you want the rest of the series as it drops — Skills, Hooks, MCP, and Subagents, all built on the same PortfolioPulse project.

DIY Smart Lock: Custom Buzzer Integration with Raspberry Pi Pico 2W, Keypad & LCD

Ricards Taujenis — Fri, 05 Jun 2026 10:35:24 +0000

Hey devs! 👋

I just put together a security project utilizing the new Raspberry Pi Pico 2W to construct an electronic passcode door lock system.

If you are getting started with MicroPython or looking for inspiration for a hardware project to tackle over the weekend, this was a fun one to code and wire up.

🛠️ The Hardware Setup

The core build features:

Raspberry Pi Pico 2W running MicroPython.
4x4 Matrix Keypad for secure PIN entry.
1602 LCD Display driven via an I2C backpack interface to minimize our pin usage.

For the wiring, I mapped the I2C lines to GP6 (SDA) and GP7 (SCL). If you try this build yourself and notice your LCD screen is completely blank or too dim, don't panic! You just need to take a small screwdriver and gently adjust the built-in potentiometer knob on the back of the I2C backpack module to fix the contrast.

🔊 The Custom Upgrade: Adding a Buzzer

While standard tutorials usually stop at visual screen confirmation, I wanted tactical audio responses to make the system feel like a commercial security device. I custom-wired a physical buzzer into the breadboard logic.

By modifying the code logic inside the Thonny IDE, the buzzer reacts dynamically based on user interaction:

Tactile Feedback: A single short click sound fires on every individual button press so you know the key registered.
Access Granted: An extended solid tone triggers when the correct security code (#992306) is successfully matched.
Access Denied: A rapid warning buzz alerts you if an invalid code is input.

📺 Full Video Walkthrough

I put together a 6-minute video showcasing the project run-through, detailing the pinouts, showing how to upload the necessary library dependencies (lcd_api and pico_i2c_lcd) to your Pico 2W board files, and demoing the buzzer sounds:

⚙️ What's Next?

The code is highly extensible. The logical next step to make this a true "door lock" would be integrating a physical 5V relay module to trigger an electromagnetic lock or a solenoid dropbolt whenever the screen reads Access Granted.

Base project logic inspired by the SunFounder Pico 2W Kit documentation, with custom script modifications written for the dynamic buzzer responses.

Let me know in the comments if you have worked with the new Pico 2W yet, or what features you would add to an open-source smart lock system!

Is Claude Pro Worth $20/Month? A Developer's Honest Take

Ricards Taujenis — Mon, 18 May 2026 19:34:49 +0000

I spent $20/month on Claude Pro for six months and almost cancelled. Then I started building my own AI agents and realized I wasn't just paying for a chatbot—I was paying for a development environment.

Here's why I'm keeping it, and whether you should too.

The Problem: Free Claude Hits Walls

If you're using the free Claude, you've hit the ceiling. You know the feeling—you're in the middle of something interesting, and suddenly:

Rate limits kick in
You're waiting 5+ minutes between responses
You can't upload larger files
Feature access is restricted

For casual use, free Claude is genuinely great. But the moment you want to build something, automate workflows, or iterate quickly on complex problems, those limitations become friction. Every constraint slows your momentum.

The real question isn't "Is Claude worth $20?" It's "How much is my time worth?"

What You Actually Get With Claude Pro

Let me break down the concrete differences:

5x Higher Rate Limits

With Pro, you go from 40 to 200 messages per 10-second window. This sounds technical, but practically? You can iterate without watching loading spinners.

When I was learning to build agents with Claude, this mattered. I'd test a prompt, adjust it, test again—5 times in a row. On free tier, that's a waiting game. On Pro, it's flow state.

Extended Thinking (The Game Changer)

This is the feature that actually justifies the cost. Extended thinking lets Claude spend extra compute time reasoning through complex problems before answering.

Example: I used it to debug a multi-step agent workflow where the logic was breaking in unexpected ways. Instead of Claude giving me a quick (and wrong) answer, extended thinking let me see its reasoning process and catch the actual issue in the agent loop.
Problem: Agent not passing context between steps
Extended thinking output:

Step 1: Identified where context was getting lost
Step 2: Traced the data flow through three functions
Step 3: Found the specific line causing the issue
Step 4: Suggested three different fixes with tradeoffs

That depth of analysis is worth $20 right there if you do it once a month.

Larger File Uploads & Vision

Pro lets you upload larger documents and use vision capabilities. When I'm building automation workflows, I can paste screenshots directly and get Claude to analyze UI layouts or debug visual issues.

Early Access to New Features

Claude Pro gets first access to new capabilities. Right now, that means you're testing Claude Code (improved coding capabilities) and Agent integration before the general public.

The Real Cost/Benefit: Productivity Gains

Here's where the math gets interesting:

Monthly Cost: $20

Realistic Time Saved (conservative estimate): 2-3 hours/month

If your time is worth:

Hobbyist ($0/hr): Probably not worth it
Freelancer ($50/hr): $100-150 in time saved = net +$80-130/month
Employed developer ($75/hr): $150-225 in time saved = net +$130-205/month
Startup founder ($∞/hr): The faster iteration speed is worth way more than $20

I'm in the "startup/learning" category right now, which is why I keep it. The extended thinking feature alone helps me debug agent architectures that would take 3x longer to figure out on free tier.

Building Agents: The Use Case That Changed My Mind

Here's my honest personal context: I'm learning to build AI agents right now, and I'm using Claude directly through this platform. The speed of iteration matters a lot.

When you're testing an agent workflow:

You adjust the system prompt
You run the agent
You check the output
You're back at step 1

On free tier, steps 1-4 take 15 minutes when you hit rate limits. On Pro, it's 2 minutes. Over a week of learning, that's hours of reclaimed time.

I actually built this blog post with the help of an AI agent I'm developing—the agent helped structure my thoughts, suggested sections, and gave me feedback. That kind of iterative work is only pleasant with higher rate limits.

![INSERT_IMAGE_HERE: Screenshot of Claude Agent creating blog structure]
A glimpse of using Claude Agent for content iteration—faster feedback loops with Pro

Watch my detailed video on getting started with Claude: https://youtu.be/wg02wUYnxQs

Who Should Actually Buy Claude Pro?

Definitely buy it if:

You're a developer iterating on code/prompts (time savings compound)
You're building AI agents or automation (extended thinking is essential)
You're using Claude for work (ROI on 2 hours saved is obvious)
You hit rate limits regularly (that's the biggest sign you need it)

Maybe skip it if:

You use Claude casually (few times a week)
You're learning but don't need rapid iteration
You have unlimited budget from a company already paying
You primarily need basic chat, not advanced reasoning

Definitely skip it if:

You're completely broke and have other priorities
You only use Claude for simple Q&A
You can work around rate limits with patience

The Real Comparison: What Changes

Here's a side-by-side of the most important differences:

Feature	Free Claude	Claude Pro
Rate Limit	40 msg/10s	200 msg/10s
Extended Thinking	❌	✅
Vision/File Size	Limited	Generous
Response Speed	Normal	Priority queue
Cost	Free	$20/month
Time saved per month	—	2-5 hours

The rate limit difference is the productivity multiplier. Everything else is nice-to-have.

My Honest Take

After six months, I'm keeping Claude Pro. Not because it's expensive (it's not), but because I've now structured my workflow around it—building agents, iterating on prompts, debugging complex logic.

The $20 covers about one hour of saved time at a decent freelance rate. Once you're in that mode, you'll easily hit that target.

But if you're using Claude for casual questions, the free tier is legitimately perfect. There's no shame in skipping Pro.

Next Steps

Try Pro free for a week — Claude offers a trial period. See if you hit rate limits.
Use extended thinking for ONE complex problem — see if the reasoning helps.
Decide based on your workflow — not based on FOMO.

If you're building anything with AI, coding, or automating workflows, give Pro a shot. If you're purely using it as a search engine replacement, stick with free.

What's your Claude use case? Drop a comment and let me know if you're Pro or sticking with free—I'm curious what tipped the scales for other developers.

P.S this was a learning material type of post with own Agent creation.

Want to dive deeper? Check out the video I referenced: https://youtu.be/wg02wUYnxQs for more on Claude's capabilities.

Why I'm Heading to Warsaw for NBX 2026

Ricards Taujenis — Thu, 19 Mar 2026 11:56:47 +0000

There's no shortage of Web3 conferences these days.

But every now and then, an event stands out - not because of the hype, but because of the people and opportunities it brings together.

That's why I'm excited to share that I'll be joining Next Block Expo 2026 as an Official Ambassador.

Warsaw Is Becoming a Web3 Hotspot

On March 24–25, Warsaw will turn into one of the most important meeting points for the European Web3 ecosystem.

We're talking about:

2,000+ attendees
140+ speakers
Builders, investors, founders - all in one place

But scale isn't what makes an event valuable.

What really matters is what happens between people.

The Underrated Advantage: Smart Networking

One thing that really stood out to me this year is the networking experience.

As part of the event, attendees get access to a dedicated app designed to:

Schedule 1:1 meetings
Discover relevant people
Navigate the event efficiently

Because the difference between a "good" conference and a truly valuable one usually comes down to one thing:

Who you meet - and how intentionally you meet them.

Why I Decided to Get Involved

Joining as an ambassador wasn't just about attending.

It's about being part of something that:

Connects the right people
Supports early-stage builders
Pushes the ecosystem forward

Web3 is at a stage where signal matters more than noise.

And events like this help surface that signal.

See You There?

If you're planning to attend Next Block Expo 2026, I'd love to connect.

🎟️ You can register here: https://lnkd.in/d4m4Y4pV
Use promo code: Mozes721
If not this time - hopefully we'll cross paths at a future edition.

OpenClaw AI Agent on Raspberry Pi

Ricards Taujenis — Tue, 24 Feb 2026 11:47:23 +0000

OpenClaw is an open-source personal AI assistant that runs locally on hardware like a Raspberry Pi, keeping your data private and under your control. If you enjoy self-hosting and experimenting with AI agents, this setup is surprisingly straightforward.

Raspberry Pi Prep

SSH into your Pi and update the system for stability:

sudo apt update && sudo apt upgrade -y

Install Node.js 22+ if missing (required for OpenClaw), plus Python for potential dependencies:

sudo apt install nodejs npm python3 python3-pip -y

Run the one-liner installer, which handles Node detection and onboarding:

curl -fsSL https://openclaw.ai/install.sh | bash

Post-install, check setup:

openclaw doctor
openclaw status
openclaw dashboard

OpenClaw Overview

In a nutshell it acts as a 24/7 AI agent with persistent memory.

It integrated with apps like Telegram, WhatsApp, Discord etc. You can choose from multiple LLM providers depending on your needs and setup.

Onboarding process

After installation, launch the guided wizard:

openclaw onboard

Process Breakdown

Step 1: LLM Selection-- Prompts for model (e.g., Gemini), then API key entry.
Step 2: Channel Setup-- Picks interface like Telegram; inputs bot token from @botfather.
Step 3: Provider Link-- Links accounts (Google for Gemini, GitHub, etc.) for skills/tools.

Telegram Setup

Message @botfather on Telegram.
Send /newbot.
Name your bot (e.g., MyOpenClawBot).
Copy the API token provided by BotFather.

Approve pairing

In Telegram, search for your new bot.
Send /start (or any message) to generate a pairing code.
On your Pi, run:

openclaw pairing approve telegram [pairing-code]

You can now test by messaging the bot - responses should sync via your selected LLM across both the dashboard and Telegram.

Final Thoughts

OpenClaw is still very new and evolving quickly. Some users are already running it on devices like the Mac mini. I'll continue testing it on my Mac and plan to link Google Calendar, Mail, and Drive to explore its full potential.

Kickstart OpenCode with OpenRouter

Ricards Taujenis — Sun, 11 Jan 2026 16:32:16 +0000

AI coding tools evolve fast, and OpenCode stands out as an open-source agent rivaling Cursor or Claude Code CLI - fully terminal-native with LSP support, multi-session handling, and 75+ LLM providers via Models.dev.

Compared to locked-in alternatives that are subscription base you can pick models pay-as-you-go prioritizing privacy and flexibility.
Check my 5-minute setup video for a quick demo.

https://youtu.be/VSN3fCJcoIc

Installation

Start with the one-liner curl install - no Docker or complex deps needed:

curl -fsSL https://opencode.ai/install | bash .

This adds the opencode CLI globally. Verify with opencode --version, then launch via opencode. For VS Code integration, it pairs seamlessly as an LSP client. Full docs: opencode.ai/docs.

OpenRouter Setup

OpenRouter powers model access via its OpenAI-compatible API - sign up at openrouter.ai, grab a key, and fund credits (pay-per-token, starting free tiers).
Export these env vars (add to ~/.zshrc for persistence):

export OPENAI_API_BASE=https://openrouter.ai/api/v1
export OPENAI_API_KEY=your-openrouter-api-key

Source your shell (source ~/.zshrc) and relaunch. Screenshot your API keys page for readers to match. This unlocks 300+ models without switching providers.
I added some credits to OpenRouter just for more advanced models for different projects.

Source your shell (source ~/.zshrc) and relaunch. Screenshot your API keys page for readers to match. This unlocks 300+ models without switching providers.

Basic Usage

Run opencode in a repo to init: It prompts project context, then use slash commands in the TUI.

/connect: Link OpenRouter (auto-detects env vars).
/models: List/select (e.g., Claude 3.5 Sonnet or GPT-4o-filter free ones).
/init: Scans repo, suggests plan (e.g., "Analyze main.rs and create layers").
Core flow: /plan for outline, /build to generate/run code, /improve for refinements.

Self-Hosting n8n in 5 Minutes: Local Docker or VPS Setup

Ricards Taujenis — Fri, 12 Dec 2025 12:57:10 +0000

As a powerful open-source workflow automation tool running locally or in own server free of charge brings huge value to build future projects!
For more info check the website https://docs.n8n.io/ otherwise lets get started! 🏁🏁🏁

Docker Setup

To run locally you just need a simple Docker command.

# Build image
docker build -t my-n8n .

# Run container
docker run -it --rm \
  --name n8n \
  -p 5678:5678 \
  -v ~/.n8n:/home/node/.n8n \
  n8nio/n8n

Here, --name sets the container name, -p maps the port, and -v ensures your workflows are saved persistently."

Then in some time(because the size is 1.3GB) it should run and in the localhost port will see above internal sign in.

And that's practically it and you can start building your workflows!

Just don't rebuild the image without saving the volumes as you may delete them as I have before!

Webhooks & ngrok

Locally if you want n8n to communicate with external applications Webhook needs to work, and for that ngrok is required.

ngrok exposes your local n8n instance to the internet, so external apps can reach your webhooks.

Once a domain has been created and API key shared the docker file would be better to be replaced with docker-compose.yml file.

version: '3.8'
services:
  n8n:
    image: n8nio/n8n:latest
    ports:
      - "5555:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your-secure-password
      - N8N_HOST=0.0.0.0
      - N8N_PORT=5678
    volumes:
      - n8n_data:/home/node/.n8n

  ngrok:
    image: ngrok/ngrok:latest
    command: ["http", "n8n:5678"]
    environment:
      - NGROK_AUTHTOKEN=your-ngrok-authtoken
    ports:
      - "4040:4040"
    depends_on:
      - n8n

volumes:
  n8n_data:

Then ones this is done and rebuild you can use Webhooks. 💪

Server setup

On a VPS with a public IP or domain, you don't need ngrok. Just point your DNS to the server and configure n8n with your domain.

As well let's then use compose file docker-compose.server.yml (tweak N8N_HOST to your domain):

version: '3.8'
services:
  n8n:
    image: n8nio/n8n:latest
    ports:
      - "5555:5678"
    environment:
      - N8N_BASIC_AUTH_ACTIVE=true
      - N8N_BASIC_AUTH_USER=admin
      - N8N_BASIC_AUTH_PASSWORD=your-secure-password
      - N8N_HOST=0.0.0.0
      - N8N_PORT=5678
    volumes:
      - n8n_data:/home/node/.n8n

  ngrok:
    image: ngrok/ngrok:latest
    command: ["http", "n8n:5678"]
    environment:
      - NGROK_AUTHTOKEN=your-ngrok-authtoken
    ports:
      - "4040:4040"
    depends_on:
      - n8n

volumes:
  n8n_data:

The restart: always ensures n8n restarts automatically if the server reboots.

And run docker compose -f docker-compose.server.yml up -d.

Whether you're experimenting locally or deploying on a VPS, n8n gives you full control over your workflows. With Docker Compose, you can scale easily, secure your instance, and connect to external apps. Start building your automations today - without subscription costs.

How AI slop impacted content creators

Ricards Taujenis — Mon, 06 Oct 2025 07:44:23 +0000

As a content creator across different media types(blogging, YT) I have been “gutted” of how much of an impact it has made personally both on view count and financial.

While AI does help tremendously it as well at the same time diminishes importance in most ‘white collar’ jobs.

📉 View Count & Revenue Decline

It is no shocker that AI-generated content flooded a lot of platforms, pushing authentic creators down in search and recommendation algorithms due to sheer
Lower visibility leads to reduced engagement, watch time, and ad revenue.

Thus, these platforms have also cut our earnings in half due to it as it’s tough to compete and less people go to platforms to gain insight on different topics.

😞 Emotional Toll on Creators

Creators feel demoralized, questioning value of their work. The joy of creating is replaced by frustration and disillusionment.
Any level of authenticity seems feels diminished even if AI can construct cases a lot better.

🧭 Why Creators Are Going Silent

Some creators step back due to the overwhelming noise and lack of reward.
Others pause to reassess their purpose and whether authenticity still has a place.

While I have kept YT to some decent level of consistency, with blogging I have not due to this ‘AI slop’ and cutting of any sorts of rewards in the platforms.

🧠 Oversaturation & Algorithmic Noise

Creators who invest time and emotion into their work get buried under generic output.
Platforms are overwhelmed with mass-produced, low-effort content.

Before AI there was already competition in the field and just raising in all “white collar” type of job, but now it really disrupts it all.

My drop in view count and earnings made me demotivated to post a article for around 3 months. Whether this is my final post or just a pause, one thing is clear — authenticity has to find new ways to shine in a noisy, AI-saturated world.

How to setup RAG with VectorDB

Ricards Taujenis — Sat, 21 Jun 2025 14:08:04 +0000

You may come across a term called RAG by now it's being rapidly adopted and introduced in 2020.

Mainly it's heavily in use for LLM-based apps, chatbots AI customer support, internal knowledge assistants etc.

📊 Brief overview

Let's create a ticker-specific RAG database table example using Pinecone. In my project I needed to map stock, crypto name: ticker symbols to extract just the ticker symbol. I have as well a Youtube video what you can check bellow. 👇️

https://youtu.be/QDe3Gi2tXR8

Database setup

As mentioned I used Pinecone but there are as well other options like using Reddis and even Postgres has some support.
So ones you have created an account create a new index(table)

There are many options and it depends of course on the LLM model you use. If you use GPT then by all means use one of the predefined GPT embeddings. There is as well Llama and Microsoft configuration, for my use case I made a "Manual configuration" due to embeddings based on all-MiniLM-L6-v2 model in HuggingFace.

https://huggingface.co/sentence-transformers/all-MiniLM-L6-v2

NOTE: It's really important to setup configs correctly as otherwise embeddings won't work. My Metric: cosine, Dimensions: 384, Type: Dense your's however may differ.

Ones created and running extract your API key and add to your .env for further embeddings.

📊 Prepare Dataset

Bellow you can see fraction of my .csv just to get a glimpse what I am embedding

text,label
TSLA,Tesla
AAPL,Apple
MSFT,Microsoft
BABA,Alibaba Group Holding Limited
...

For LLM I recommend using Jupyter or Google Colab rather then a regular IDE.

import os
from dotenv import load_dotenv
from sentence_transformers import SentenceTransformer
from datasets import load_dataset
from pinecone import Pinecone

load_dotenv()
pc_api_key= os.getenv("PINECONE_API_KEY")

dataset = load_dataset("Mozes721/stock-crypto-weather-dataset", data_files="crypto_mapppings.csv")
df = dataset["train"].to_pandas()

In above code I just import required packages like pinecone, and sentence_transformers used for embeddings.

I stored my training data in https://huggingface.co/new-dataset due to the fact it's LLM related same as for fine tunning rather then locally, but that is individual choice.

Build Alias Map

# Step 2: Create alias map
alias_to_ticker = {}

for _, row in df.iterrows():
    ticker = row['text'].upper()
    name = row['label'].lower()
    alias_to_ticker[ticker] = ticker
    alias_to_ticker[name] = ticker
    # Optional: add lowercase ticker too
    alias_to_ticker[ticker.lower()] = ticker

# Step 3: Prepare for embedding
aliases = list(alias_to_ticker.keys())
tickers = [alias_to_ticker[a] for a in aliases]

# Embed
model = SentenceTransformer('all-MiniLM-L6-v2')
embeddings = model.encode(aliases, convert_to_numpy=True)

# Step 5: Load Pinecone table
pc = Pinecone(api_key=pc_api_key)
index = pc.Index("stock-index")

So alias map is created and in the for loop iterate over rows on text and label. Append to alias tuple both name and ticker( in my mappings it should work on both ends if AAPL given should return AAPL if Apple then AAPL).

Then we fetch the model we want to embed it to and encode by converting to numpy ad then for now just load the index table.

Embed & Store in Pinecone

# Prepare vectors in correct format
vectors = []
for i in range(len(aliases)):
    vectors.append({
        "id": f"stock_{i}",
        "values": embeddings[i].tolist(),
        "metadata": {"ticker": tickers[i], "alias": aliases[i]}
    })

# Batch upsert to avoid 2MB limit
batch_size = 50
total_batches = (len(vectors) + batch_size - 1) // batch_size

for i in range(0, len(vectors), batch_size):
    batch = vectors[i:i + batch_size]
    index.upsert(vectors=batch)
    batch_num = i // batch_size + 1
    print(f"Batch {batch_num}/{total_batches} has been embedded and uploaded ({len(batch)} vectors)")

print("All city batches completed!")

The vectors should be prepared in an array, we go through a for loop in aliases. Then append to vector and have id, values and metadata defined.

Uploading to Pinecone needs to be done in batches to avoid 2MB upsert limit. When its done with batch_size we can upsert to stock-index table.

🤖 Querying with RAG

The testing face should be quite simple as long as data has been embedded properly and same LLM model is used.]

import os
from dotenv import load_dotenv
from sentence_transformers import SentenceTransformer
from pinecone import (
    Pinecone
)

class EmbeddingStockMapper:
    def __init__(self, model_name: str, pinecone_api_key: str):
        # Initialize the embedding model
        self.model = SentenceTransformer(model_name)

        pc = Pinecone(api_key=pinecone_api_key)
        self.index = pc.Index("stock-index")

    def get_stock_ticker(self, query):
        # Get embedding for the query
        query_embedding = self.model.encode(query, convert_to_numpy=True)

        # Search in Pinecone
        results = self.index.query(
            vector=query_embedding.tolist(),
            top_k=1,
            include_metadata=True
        )

        if results.matches:
            return results.matches[0].metadata['ticker']
        return None

# Initialize the mapper
load_dotenv()
pc_api_key= os.getenv("PINECONE_API_KEY")
mapper = EmbeddingStockMapper(model_name="all-MiniLM-L6-v2", pinecone_api_key=pc_api_key)

So we initialize the model with all-MiniLM-L6-v2 same as used before in embedings. Then create a method get_stock_ticker that will encode the query passed to it. It will then return a result.matches[0].metadata['ticker'] as per own specification that most closely matches.

test_queries = ["AAPL", "Apple Inc.", "apple", "What is the current stock price of Tesla.", "Google", "google", "TSLA", "Tesla", "tesla", "Microsoft Corporation", "microsoft"]

for query in test_queries:
    ticker = mapper.get_stock_ticker(query)
    print(f"Query: {query} -> Ticker: {ticker}")

//Output
Query: AAPL -> Ticker: AAPL
Query: Apple Inc. -> Ticker: AAPL
Query: apple -> Ticker: AAPL
Query: What is the current stock price of Tesla. -> Ticker: TSLA
Query: Google -> Ticker: GOOGL
Query: google -> Ticker: GOOGL
Query: TSLA -> Ticker: TSLA
Query: Tesla -> Ticker: TSLA
Query: tesla -> Ticker: TSLA
Query: Microsoft Corporation -> Ticker: MSFT
Query: microsoft -> Ticker: MSFT

Above you can see how it gracefully returned ticker symbols as per my request!

In all honesty I was astonished by the results. RAG is slowly getting traction and I think a this is a lot better approach even if there is a learning curve compared to just using ChatGPT API calls. But most of us have simple need for AI implementation so using the whole AI model can be deemed as an "overkill".

My repo you can find here for any questions feel free to ask.

Vibe Coding: The Good and the Ugly

Ricards Taujenis — Thu, 08 May 2025 13:27:40 +0000

If you have been around the dev block recently, you most likely heard of this new trend "vibe coding" my friend roped me into trying it with Cursor, and let me just tell you I have mixed feelings about it. Here's why.

The Good

When it comes to building a new project it feels liberating to vibe yourself to success! Not the same with legacy code however but not impossible.

Real-time feedback and rapid iteration

Cursor(like WindSurf) updates on the fly, making it a lot more faster and you don't have to switch between writing and running as not only it updates scripts but it can as well create new ones!

As you can see from above screenshot for Cursor it at first asked for permission to mkdir and then automatically created schema.sql script.

Fresh start

Vibe coding on fresh project creates less baggage compared to legacy code. In addition it gives you sense of momentum, exploration and blazingly fast builds!
In addition it can do deploys to your Cloud provider if ssh keys are present and manage it in terminal(so not just code).

Great for ideation and brainstorming

Stuck on what tools to use? Postgres or Mongo? RabbitMQ? Kubernetes? Or what API system to use and even language Cursor and other AI IDEs can help with that by leveraging it's deep understanding of all the tools in the disposal.

Just have to be explicit and scaffold based on my goals, and then gives me full stack with languages, reasoning and tools.

I asked a question of what I am included to build and to follow up with README.md tech stack and architecture tree including language of choice and other tools that would be optimal. ☝️

The Ugly

Even though these AI IDEs have access to your whole repo, they can still duplicate logic and other issues mentioned bellow. Thus extensive monitoring and NOT commiting before checking is a must. 🕵🏻

Code duplication

While code assistant IDEs have access to whole repo, it still sometimes create same functions in different directories. Like I had with my Rust project bellow. 👇

If you pay attention you can see that verify_pin function was created in plugin, service and utils module lvl by Cursor, so when some code doesn't work it can often recreate similar logic elsewhere and forget that there is already something implemented.

Tooling mismatch

This hits hardest in JavaScript and Python. With massive ecosystems, AI assistants often install libraries that don't play well together - or that are outdated.

With React it can install certain dependencies like Supabase client and server side dependencies, same as with TS that are not compatible.

As we all know we can not always use the latest packages and documentation/methods are not available for some packages or are stale with AI not knowing it but just pasting.

Too fast, lack of reasoning

Sometimes it feels too easy to "vibe yourself to success", but often context of repo is misunderstood and explanation of WHY particular approach was taken falls short. Thus it's easy to fall into deep woods when you see 10 scripts generate and instead of reasoning and understand it you just close a blind eye and hope for AI Gods to fix possible issues.

To conclude I must say Cursor undeniably is a game-changer. But just because something becomes 3x easier doesn't mean it can not wrap up "technical debt" in the future, especially if your not fully familiar with the tech like me when it comes to Rust.

The $20/month price is a bit steep, especially when WindSurf offers a free tier and GitHub Copilot is cheaper. Still, for now, I'm sticking with Cursor.

That said, I'll be more cautious. Just because the assistant offers changes doesn't mean you should accept them blindly. Review them. Test them. Because duplicated functions, unnecessary utils, and mismatched packages can snowball fast.

Local Llama Setup: A Python Developer's Guide

Ricards Taujenis — Thu, 23 Jan 2025 00:42:53 +0000

As using chatGPTis API is becoming more and more expensive and number of tokens are limited there comes a point in your life that have to look for alternatives. Thats where Llama comes in!

Alternatively you can use smaller models (3B parameters instead of 7B)
Use bitsandbytes for 8-bit quantization, which reduces memory usage significantly.
If you don't have strong GPU can always outsource to cloud options that are out there like Google Colab, Hugging Face Inference API, RunPod

Accessing Llama Models

To start off Hugging Face is the primary platform used for accessing Llama models(e.g., meta-llama/Llama-2-7b-chat-hf).

https://huggingface.co

Create your account in Hugging Face👆 to start using LLM models provided by Llama.
If your ambitious can as well create own model if not there are a bunch of models to choose from. 🤖

Most people including me just need text-to-text model so typical choose would be meta-llama/Llama-2–7b-chat-hf.

Once the model has been selected be sure to request access to the model by adding credentials.

huggingface-cli login

Then you will have to login in terminal to use the models. In your huggingface profile go to Settings > Access Tokens, generate your access token that you will paste in.

Using the Model

In your python app we should use conda instead of regular venv be sure to install it activating it is similar as venv.

https://docs.anaconda.com/working-with-conda/environments/

//Required instalation for conda PyTorch
conda install pytorch torchvision torchaudio cpuonly -c pytorch
//Required python packages for huggingface etc
pip install transformers accelerate sentencepiece huggingface_hub
//To reduce memory usage you can as well install
pip install bitsandbytes
//Activate conda
conda activate myenv

For this demonstration will just make it a simple as possible in main.py the power lies when implementing RAG (Retrieval-Augmented Generation)) or fine tuning the model.

import transformers
import torch

def main():
    # Load Llama model using transformers pipeline
    pipeline = transformers.pipeline(
        "text-generation",
        model="meta-llama/Llama-2-7b-chat-hf",  # Replace with your model path if using a local model
        model_kwargs={"torch_dtype": torch.bfloat16},
        device_map="auto"
    )

    # Start the Llama pipeline
    while True:
        # Get user input
        query = input("\nYou: ")

        # Exit condition
        if query.lower() in ["exit", "quit"]:
            print("Goodbye!")
            break

        # Handle the query
        try:
            # Construct the prompt
            messages = [
                {"role": "user", "content": query},
            ]

            # Generate a response using the Llama model
            outputs = pipeline(
                messages,
                max_new_tokens=256,  # Adjust as needed
            )

            # Extract and print the response
            response = outputs[0]["generated_text"][-1]["content"]
            print(f"Bot: {response}")
        except Exception as e:
            print(f"Error handling query: {e}")

if __name__ == "__main__":
    main()

Note: The model i used computation heavy(CPU, GPU) and due to enormous parameters this particular 7 Billion parameters so if it doesn't break and hangs it may be due to weak PC.

Conclusion

As AI doesn't seem to fade and hype keeps on going good good to be more familiarized with it if not building own model might as well implement in own project with fine tuning or implementing it with RAG.
Of course IF your PC can handle it. 😉

Can Pinterest Help Build Your Personal Brand?

Ricards Taujenis — Tue, 10 Dec 2024 21:33:04 +0000

In todays age personal branding is more important then ever, while most of us focus on YouTube, blogging, personal website, GitHub(as a developer), Link bio(like linktree).

Pinterest works similarly to affiliate links, directing users to external content where the shared content actually resides.

While it's true that Pinterest is better suited for creative, visually-driven fields like art, tattoos, and fashion, it can also be a valuable tool for IT professionals. Although results may not be instantaneous, men and women alike can leverage Pinterest for personal branding.

Setting up Pinterest

Ones you login with email, google or facebook you can start by creating different boards based on content that you want to share.

Above you can see my different boards i have created over time(the last one i have been invited to).

Some social platforms like YouTube will automatically suggest option to create a Pin on Pinterest. If not I suggest create manually through Canva by selecting Pinterest pin 👇

https://www.canva.com/

Pinterest offers SEO benefits that can drive traffic to your website or content. Additionally, there are paid options for promoting pins, but I use the free version.

Statistics

Out of the many pins I've created, some have performed exceptionally well. For instance, my article 'How to Stop Vaping for Good' received 25 clicks, with 8 coming from Pinterest.

As you can see from above picture while most dont get any traction I made one article listed bellow.

https://richard-taujenis.medium.com/how-to-stop-vaping-for-good-bb3e0563648e

So while it doesn't occur often it doesn't take as much time to create a Pin.

Bellow you can see how much pins i have created reality paints a different picture often in life compared to what we expect.

https://pl.pinterest.com/richardtaujenis/

Branding yourself in a digital landscape has never been as competitive and saturated as it is now. While people say "you have to stand out from the rest" has never been more difficult, as when everyone is doing the same thing how to stand out?

While Pinterest may not always bring immediate results, its potential for long-term brand building is significant. Don't overlook this powerful platform in your personal branding strategy.