DEV Community: Hope

Visual Cue Tracker: Mapping My Values, One Week at a Time

Hope — Sun, 07 Jun 2026 00:15:05 +0000

This is a submission for the GitHub Finish-Up-A-Thon Challenge

What I Built

I built the Visual Cue Tracker, a tiny, personal sanctuary for reflection. It’s a tool designed to help us map our daily actions against our core values, specifically Empathy, Growth, and Balance.

I started this project because I found myself moving so fast in my software engineering studies and internships that I often forgot why I was doing what I was doing. This tracker lets me see my week at a glance, reflect on my progress, and hold space for the things that truly matter to me.

Demo

Deployed site:

hopebestworld.github.io

github repo: https://github.com/HopeBestWorld/VisualCueTracker/tree/main

demo: https://youtu.be/EqVfj289e-Q

The Comeback Story

When I first started this project, it was just a repo with no pushed code. In 2025, I simply set up the repo and put in a description, but never put the time or effort into bringing the idea to life. To finish it up for the challenge, I added a few things that made it feel truly alive.

I built a custom, zero-key AI engine that runs entirely inside your browser. It scans your weekly reflections and gives you immediate, gentle feedback on how well your written thoughts match the values you logged.

It suggests! If I’m missing the mark, it gives me specific prompts to help me get back to my goals.

I added quick-export features so I can turn my weekly reflections into a clean text log, making it easy to keep a personal journal outside of the app.

I set up a fully automated deployment pipeline using GitHub Actions, so my site updates instantly whenever I push my code.

My Experience with GitHub Copilot

GitHub Copilot felt like a supportive coding partner throughout this journey. When I was stuck on complex pathing issues for my GitHub Pages deployment, it helped me iterate through solutions quickly. It was especially great at explaining why certain parts of my code (like my custom Regex AI engine) were behaving the way they were, allowing me to stay in a flow state without needing to constantly stop and search for syntax.

Building a Friendly Data Assistant

Hope — Sun, 31 May 2026 18:53:06 +0000

This is a submission for the Hermes Agent Challenge: Write About Hermes Agent

Hello, DEV friends! 👋

If you have been exploring the world of Artificial Intelligence lately, you have probably heard a lot of buzz about "AI Agents." But what does it actually feel like to build with one?

Today, I want to share my personal experience working with Hermes Agent. I used it to build a smart assistant called the Alpha-Dairy Quant Pipeline—a system that helps track and make sense of food market data. (https://github.com/HopeBestWorld/alpha-dairy-pipeline)

Whether you are an expert coder or just curious about AI, I hope this friendly guide inspires you to try building an agent of your own!

What is Hermes Agent, Anyway?

Think of a standard AI as a helpful chatbot that answers questions when you ask them. An AI Agent, on the other hand, is more like a proactive assistant. You give it a big goal, and it sits down, makes a step-by-step plan, uses digital tools, runs code, and checks its own work until the job is done.

For my project, I wanted to track market prices for three major dairy products: Cheddar Blocks, Butter, and Dry Whey. Instead of doing all the math and graphing by myself, I let Hermes Agent take the wheel.

The Magic of Multi-Step Reasoning

The coolest part of working with Hermes Agent is watching it "think". When I asked my agent to look at our data database (market_intelligence_3.db) and find the best trading strategy,it followed a beautiful planning loop:

Checking the Files: It looked at our setup files (tickers.yaml and requirements.txt) to make sure all its tools were ready.
Running the Math: It triggered a Python program (backtest_engine.py) to study weekly market history.
Making Decisions: It realized that Dry Whey was way too wild and risky to trade right now, so it intelligently gave it a 0% safety rating and put the focus on Cheddar and Butter instead.
Drawing and Sharing: It automatically drew a beautiful performance chart (backtest_analysis.png), saved the numbers to a spreadsheet (portfolio_comparison.csv), and sent a neat summary directly to our team chat!

What I Learned & Tips for Success

Working with open agent systems taught me a couple of great lessons:

Clear instructions matter: Agents do best when you give them clear boundaries. Writing down simple project rules in a file called AGENTS.md helped my assistant stay perfectly on track.
Uncorrelated doesn't mean helpful: Just because an asset moves differently from others doesn't make it a safe bet if it is losing value. My agent figured this out mathematically and saved us from a bad investment!

How I Want to Improve This Work

This is just the beginning! If I had more time to expand this project, here is the future work I would love to tackle:

Live Pings: Right now, the pipeline runs when we ask it to. I want to use a script like fetch_live_data.py to pull live data from the web and have the agent send an automatic text alert if prices drop suddenly.
Teaching the Agent to Read News: I want to give the agent a web-browsing tool so it can read daily farming and business news headlines. This would help it combine math data with real-world news events!
A Simple Dashboard: I would love to build a colorful, easy-to-read website where anyone can see the agent's latest recommendations without needing to look at text logs.

I am so grateful to have participated in the Hermes Agent Challenge! It has completely changed how I think about programming and automated data systems.

Building a Local AI Market Trader with Hermes Agent

Hope — Sun, 31 May 2026 18:12:44 +0000

This is a submission for the Hermes Agent Challenge: Build With Hermes Agent

What I Built

I built Alpha-Dairy Quant Pipeline. It is an automated system for tracking and trading dairy products (like Cheddar Blocks, Butter, and Dry Whey) using math and data.

The system automatically pulls market numbers, tests a smart trading strategy, figures out the best way to divide money between the products, and shares updates with team members. This solves the problem of trying to guess when to buy or sell food commodities by letting an AI agent safely handle the data work.

Demo

Instead of a video, here are the direct outputs and screenshots from our live project setup.

1. Automated Chat Outputs

Our system connects directly to a Discord channel. When asked to run the engine, the agent plans out the task and outputs a clean market report:

The agent creates and attaches a high-resolution chart directly to the chat to show performance against the baseline market indexes.

The agent also exports and uploads a clean spreadsheet tracking file for easy backup downloads.

Code

You can view the full repository here:
👉 GitHub Link: alpha-dairy-pipeline

My Tech Stack

AI Agent Engine: Hermes Agent Framework

Language: Python 3.12
Data Math libraries: Pandas, NumPy, and SciPy
Graphs & Visuals: Matplotlib

Data Retrieval: yFinance API

Database Store: SQLite

Platform Chat Bridge:* Discord Bot Integration

How I Used Hermes Agent

Hermes Agent acts as the intelligent director at the center of the entire project. I relied heavily on its unique agentic skills to perform real, complex work:

Multi-Step Planning: The agent maps out its own checklist (such as reading market data files, running the script, and checking metrics) without hardcoded steps.

Tool Use and Code Execution: The agent safely spawns a sandboxed python execution runtime to process thousands of data points across 28 years of history, run math optimizations, and render image files.

Autonomous Documentation: After finding that Dry Whey had massive volatility (~103% annualized), the agent automatically went in and updated our project's persistent file (MEMORY.md) with a written explanation of the statistical risk to keep the team aligned.

I Built a Token System on Solana (Without Any Backend Code)

Hope — Mon, 25 May 2026 03:37:30 +0000

If you told me a week ago that I could create a custom currency, add brand metadata, enforce automatic transaction fees, and create "soulbound" non-transferable credentials—all without writing a single line of backend API code—I would have been skeptical.

Coming from a Web2 background, my brain is wired to think in APIs, Databases, and Middleware.

But over the last few days, I’ve been building on Solana using the Token Extensions (Token-2022) Program, and it has completely changed how I think about building apps.

The Web2 Way vs. The Solana Way

In a traditional web app, if I wanted to launch a "Reward Coin" system, I’d have to:

Build a database table to store balances.
Write an API endpoint to check if a user has enough coins.
Write a tax-collection service to skim fees off transfers.
Add security checks to make sure users can't edit the database themselves.

On Solana, the protocol handles the heavy lifting.

My Token-Building Journey

This week, I walked through the full lifecycle of token design. Here is what I learned about these three "superpowers" of Solana tokens:

1. Metadata: Tokens with an Identity

A token without metadata is just a nameless string of characters. Using spl-token initialize-metadata, I attached a name, symbol, and image link directly to my token mint.

The Lesson: You aren't just storing a number; you are attaching an identity to an asset that lives on-chain forever.

2. Transfer Fees: Protocol-Level Revenue

This was the most eye-opening part. I created a token with a built-in 2% transfer fee.

The Why: In Web2, I’d need a complex payment processor. Here, I just set a --transfer-fee parameter. When a user sends 100 tokens, the program automatically withholds 2 tokens in a locked state, and I can sweep them into my treasury whenever I want.
The Surprise: The blockchain rejects any transaction that doesn't account for the fee. The security is enforced by the math, not by my backend code.

3. Non-Transferable Tokens: The "Soulbound" Credential

Finally, I experimented with the --enable-non-transferable flag. This creates a token that is permanently "stuck" to the wallet that receives it.

Use Case: Think of course certificates, membership badges, or employee IDs.
The Proof: I literally tried to send these tokens to a second wallet, and the Solana network threw a Transfer is disabled error. It wasn't my code failing; it was the blockchain itself saying "No."

What Surprised Me Most

The biggest hurdle was the "Decimal Math." When you set your token to 9 decimals, everything is calculated in "base units." I hit a few errors where my expected fee didn't match the program's calculation because I was thinking in whole numbers rather than the token's smallest unit. Once I understood that the program was calculating the exact math, the errors disappeared.

What’s Next?

Moving from "I can send SOL" to "I can define the economic rules of an asset" feels like a huge level-up.

If you are a developer looking to get into Web3, don't just read the docs—start by building a token. It forces you to understand account ownership, rent, and data storage faster than any tutorial ever could.

I’m excited to keep building. Next up, I’m looking into how to connect these tokens to a frontend dashboard. If you're also learning Solana, let’s connect!

Solana Accounts Explained to a Web2 Developer

Hope — Fri, 22 May 2026 14:56:09 +0000

If you are coming from a traditional Web2 background (like building with Node.js, databases, or cloud servers), your first look at a blockchain can be confusing. You hear terms like smart contracts and state transition, but how does data get saved?

On Solana, Everything is a file.

Well, Solana calls them Accounts, but they act just like files in a computer operating system. Let's break down how Solana stores data using terms you already know.

1. The Big Idea: Everything is a File (Account)

In Web2, you might use a Linux server. On that server, you have executable files (programs) and data files (such as .json or .txt).

Solana works the same way. Instead of a hard drive, Solana uses a giant, flat key-value store.

The Key: A 32-byte string called a Public Key (like So11111111111111111111111111111111111111112). This is your file name or path.
The Value: The account itself. This is the actual file contents and metadata.

Whether it's a user wallet, a piece of code, a token balance, or a picture of an NFT—on Solana, it is always an account.

2. The 5 Fields Inside Every Account

Just like a file on your computer has a size, an owner, and permissions, every single Solana account contains the same five pieces of information:

Field	What it means in Web2 terms
Lamports	The bank balance of the file. A lamport is a tiny fraction of a SOL coin (1 SOL = 1 billion lamports).
Data	The actual contents of the file. A flat array of bytes where you can save any information.
Owner	The specific program (app) that is allowed to change this file's data.
Executable	A true/false switch. If true, this file is a program (code). If false, it's just data.
Rent Epoch	A background field used by the network (mostly system maintenance data).

Here is what it looks like if you inspect a real account using the Solana command line:

{
  "lamports": 2039280,
  "data": ["SGVsbG8gV29ybGQ=", "base64"],
  "owner": "11111111111111111111111111111111",
  "executable": false,
  "rent_epoch": 18446744073709551615
}

3. Programs are Stateless

This is the biggest surprise for Web2 developers.

In Web2, your app server usually holds some data in memory, or your code handles its own database connections. On Solana, programs (smart contracts) cannot store data inside themselves. They are stateless.

Think of it like this:

The Program Account: This is your compiled code. Its executable flag is set to true. It sits there like a web server application, ready to run.
The Data Account: This is your database row. Its executable flag is false.

When a user wants to interact with an app, they pass both the Program (the code) and the Data Account (the file) to the network. The program reads the data file, updates it, and saves it back.

4. The Golden Rule: App Security

How do we stop people from changing your data account and giving themselves a million tokens? Solana has a very strict security rule built into its core:

Only the program listed as the "Owner" of an account can change its data.

If Program A tries to modify a data file owned by Program B, the Solana network rejects the change. However, anyone is allowed to send money (lamports) into any account. You can deposit money into a friend's bank account, but only the bank's system can update their account status.

5. Rent: Paying for Storage Space

On a cloud platform like AWS, you pay a monthly fee to keep your files stored on a hard drive. If you stop paying, AWS deletes your files.

Solana manages storage similarly, but with a twist. To keep a file on the blockchain, the account must hold a minimum amount of SOL coins. The bigger your data file, the more SOL you need to leave in it. This is called being Rent-Exempt.

For a basic wallet account with no extra data, it costs a tiny fraction of a cent (around 0.00089 SOL) to stay on the network forever. If you ever close the account and delete the file, you get all that SOL back!

Wrapping Up

To survive and build on Solana, just remember these four rules:

Everything is a file called an account.
Code and data live in completely separate files.
Programs are stateless; they just read and write to data accounts.
Only the owner program can modify a file's data.

Once you view the blockchain as a giant, secure file system, writing applications becomes much easier to visualize!

Victory Lap

Hope — Tue, 05 May 2026 04:23:59 +0000

I’ve been diving into Solana development for the past 10+ days as part of 100DaysOfSolana.

Today, I successfully moved my scripts into the browser to build a functional Devnet Dashboard. It was a great exercise in handling RPC providers and managing BigInt data for UI display.

Major shoutout to Major League Hacking for the challenge. Looking forward to the next arc!

My Second Week Building on Solana

Hope — Sun, 03 May 2026 15:11:52 +0000

I just finished my second week of the #100DaysOfSolana challenge, and my brain feels like it’s been rewired. Coming from a traditional software background, I thought a blockchain was just a slow database. I was wrong.

The "Aha!" Moment: Everything is an Account

The biggest thing that clicked for me this week was the Account Model. In the apps I usually build, data lives in a private database (like MongoDB) and the code lives on a server. On Solana, everything—your wallet, your data, and even the "smart contract" code—is an account sitting on a giant, public ledger.

What Surprised Me

I spent today comparing Solana accounts to traditional databases. Here are the three things that shocked me most:

Public by Default: I can take my wallet address, throw it into a website like the Solana Explorer, and see every single transaction I’ve ever made. There’s no "admin password" needed to see the data—it’s just there.
Rent is Real: You actually have to pay a small "security deposit" in SOL to store data on the blockchain. If you want to store more bytes, you pay more. The cool part? If you delete the data, you get your money back.
The "Ghost" Transaction: I learned the hard way that just because a website says "Success" doesn't mean your money has arrived yet. You have to wait for the network to "finalize" the transaction.

My Terminal Adventures

I spent a lot of time in the terminal this week. One of the most satisfying moments was finally seeing my balance update after a few failed airdrops:

# Checking my "identity" on the devnet
solana account $(solana address)

# The result:
Public Key: 5bsSMz6oc4gHp5BkBFSR9HK4mn7NBTimvsgSL9soXktj
Balance: 1.5 SOL
Owner: 11111111111111111111111111111111 (System Program)
Executable: false

What's Next?

I’m still wrapping my head around how different programs talk to each other without using "JOIN" commands like in SQL. It feels like learning to walk again, but in a world where everything is transparent and decentralized.

Next week, I’m diving deeper into building dashboards that read this data in real-time!

My Wallet Experiences

Hope — Sun, 26 Apr 2026 22:29:11 +0000

What I did: This week, I went from generating raw key pairs in the terminal to building a web app that connects to browser wallets like Phantom.

What surprised me: The biggest "aha" moment was realizing that a wallet is a UI for a cryptographic key pair that serves as my universal identity.

What's next: I'm excited to move past the basics and start writing my own on-chain programs!

How Identity Actually Works on Solana

Hope — Sun, 26 Apr 2026 22:14:51 +0000

Beyond Passwords: Understanding Identity on Solana

In the Web2 world, your identity is basically a row in a database owned by someone else. You have a username for GitHub and an email for Google. You rely on these companies to hash your password, handle forgotten password emails, and keep your data safe. On Solana, there are no databases or admins. Your identity is built on the keypair.

Think of it Like an SSH Key

If you’ve ever connected to a server using an SSH key, you already understand Solana. You generate a public key and a private key. You share the public one and keep the private one hidden. To prove who you are, you use the private key to sign a request.

On Solana, the entire network is the server. Your public key is your address, and your private key is your proof of ownership. To move money or talk to a smart contract, you just sign the request with that private key.

Why Addresses Look So Weird

Instead of a username, a Solana address looks like a long string of random characters. This string is encoded in Base58.

Solana uses Base58 to prevent human errors. It removes confusing characters that look alike, such as:

The number zero (0)
The capital letter O
The capital letter I
The lowercase letter l

This makes it much harder to make a mistake when you are copying or reading an address.

You Are the Only Boss

In Web2, a company can lock your account or get hacked. They own your data. You just have permission to use it. On Solana, ownership is cryptographic. Only the person holding the private key can make changes.

There is no password reset button. If you lose your private key, you lose your account forever. While that sounds scary, it also means no company or admin can ever block you or take your funds. You are in total control.

One Key for Everything

Because your identity is based on math, it works everywhere. You just connect your wallet, and every game, marketplace, or exchange on the network instantly knows it's you. It’s like having a universal passport that works across the entire internet without needing anyone's permission.