DEV Community: NIRANJAN LAMICHHANE

From Android Engineer to AI/ML – My Journey and First Realization

NIRANJAN LAMICHHANE — Fri, 07 Aug 2026 15:15:46 +0000

Starting my journey as the AI/ML engineer from Android Engineer... My current goal is to win a hackathon/competition related to this domain within 60 days and secure a job/contract related within 100 days.

I will be documenting the concepts learned and things experimented in this series of dev.to posts.

My Curiosity

First of all, I started with the following curiosity in the mind:

What's the role of machine learning in software engineering?
What problem will it try to solve, or solve which traditional approach of programming cannot?
What are its usecases?

My Discovery

Till now, what I discovered is that machine learning can be a replacement/alternative/substitute of conditional statements (if..else, while loop, etc.) of the conventional programming approach.

When you have just a few branches, conditional statements work perfectly. But when the number of rules becomes huge — like trying to decide something based on hundreds or thousands of possible conditions — hand-coding all those if-else paths turns into a tangled mess that’s hard to maintain and scale.

Here to solve this we train the model on the data (condition, value). We predict the value from the condition using this trained model.

The Sweet Spot (Still Searching)

However, I have not discovered the sweet spot for machine learning from which branching of conditional statements are to be replaced. But I am pretty sure that machine learning should not be imposed on the place where conditional statement branches will do the thing.

Is my understanding correct? Please give your feedback and view.

This much for today from my side. Will keep updating about my journey.

I Built a Nepal Government Complaint Transparency Bot with Hermes Agent (From Zero, in One Hour )

NIRANJAN LAMICHHANE — Mon, 01 Jun 2026 06:23:59 +0000

This is a submission for the Hermes Agent Challenge

What I Built

Hello Sarkar Analyzer — a Telegram bot that fetches, analyzes, and reports on public complaints filed by citizens with the Nepal Government at gunaso.opmcm.gov.np.

Nepal's Hello Sarkar ("Hello Government") portal lets citizens file complaints against any government ministry or department. The data is public — but buried inside a JavaScript-heavy Nuxt.js app that most people never dig into. My bot surfaces that data instantly on Telegram:

/complaints — live analysis: total complaints, resolved vs pending, resolution rate, top 3 most complained-about departments
/report — downloads a full .txt civic report to your phone
/about — project background

The goal: make government accountability data accessible to any Nepali citizen with a phone.

Demo

Bot commands in action:

/complaints

🏛 Hello Sarkar — Civic Complaint Analysis
📅 2026-06-01 11:30 NPT

📊 Overview
• Total:       847
• ✅ Resolved: 312 (36.8%)
• ⏳ Pending:  535

🏆 Top 3 Most Complained Departments
  1. Ministry of Land Management — 143 complaints
  2. Department of Transport — 98 complaints
  3. Ministry of Local Government — 87 complaints

🔗 gunaso.opmcm.gov.np
Built with Hermes Agent 🤖

Image demo :

Code and My Tech Stack

Hermes Agent by Nous Research — wrote, debugged, and ran all code
Python 3 — bot runtime
python-telegram-bot — Telegram interface
Selenium + headless Chrome — JavaScript page rendering
BeautifulSoup4 — DOM parsing
WSL2 / Ubuntu — development environment

I have no idea except for hermes agent and wsl2 and how other is used .

How I Used Hermes Agent

Here's the honest story: I came to this challenge as someone who had never used Hermes Agent before. I spent the first half of the day just getting it installed.

The Setup Journey

I started from absolute zero — no curl, no pip, no WSL2. After installing WSL2, I discovered I was running as root (no sudo), apt wasn't in PATH, and pip threw externally-managed-environment errors. Every step had a new obstacle.

What got me through it was Hermes Agent's ability to diagnose its own environment. Running hermes doctor gave me a clear picture of what was working and what wasn't — 18 of 27 tools enabled on a completely fresh setup.

The Build

Once running, I gave Hermes this prompt:

"Create a Telegram bot that fetches and analyzes public complaints from gunaso.opmcm.gov.np. The site is a Nuxt.js SPA — figure out how to get the data."

Hermes immediately identified the real challenge: the site renders everything in JavaScript. It couldn't just use requests + BeautifulSoup. So it autonomously:

Wrote a multi-layer scraper that tries 8 known Nepal govt API URL patterns first
Falls back to Selenium with headless Chrome to actually render the page
Intercepts real XHR/fetch calls the browser makes to find the live API endpoint
Parses the rendered DOM as a final fallback

When it hit a TERMINAL_SSH_PORT config error blocking code execution, it diagnosed the cause (a bad hostname from earlier SSH setup), fixed the .env file, and continued — without me telling it what was wrong.

When the bot crashed with AttributeError: 'list' object has no attribute 'get' — because the API returned lists-of-lists instead of dicts — Hermes identified the data shape mismatch and rewrote the analyze() function to handle all three possible shapes: dict, list, and raw str.

I wrote zero lines of this bot. Every function, every fallback strategy, every bug fix came from Hermes Agent reasoning through the problem autonomously.

What Surprised Me

The thing that struck me most was how Hermes handled ambiguity. The Nepal government site doesn't document its API. There's no public endpoint listed anywhere.

That layered reasoning — try the smart thing, then the less smart thing, then the brute force thing — felt genuinely agentic. Not just code generation. Problem solving.

Why This Matters for Nepal 🇳🇵

Nepal's Hello Sarkar portal holds real accountability data — which ministries get the most complaints, how long resolutions take, what citizens are suffering through. That data is technically public but practically inaccessible to most people.

A Telegram bot changes that. Telegram has deep penetration in Nepal. Any citizen, journalist, or civil society researcher can now type /complaints and get instant civic insight — no browser, no technical knowledge needed.

Hermes Agent made this possible in a single afternoon, from a country where most AI agent tutorials assume you already have a working dev environment with brew install everything. Starting from apt not found and ending with a working Telegram bot connected to live government data — that's the real demo.

Built by Niranjan Lamichhane, Kathmandu, Nepal 🇳🇵
Powered by Hermes Agent + OpenRouter (free tier) + WSL2

Building Multi‑Extension Tokens on Solana and making it compliance goated

NIRANJAN LAMICHHANE — Fri, 29 May 2026 09:13:13 +0000

After 36 days of diving into Solana development, I finally reached the most exciting milestone: composability.

Solana’s Token Extensions allow you to combine multiple features into a single mint — without writing complex smart contract logic.

In this post, I’ll walk you through two real‑world scenarios:

Day 37 – A token with transfer fee, interest‑bearing, and metadata extensions.
Day 38 – A compliance‑gated token with default frozen accounts (perfect for regulated finance).

All commands are tested on Devnet using the spl-token CLI. Let’s go!

Day 37: The Triple‑Extension Token

The Goal

Create a mint that:

Charges a 1% transfer fee (capped at 5 tokens).
Grows in value over time (interest‑bearing, 5 bps annually).
Stores its name, symbol, and URI directly on‑chain (metadata).

Step 1 – Create the Mint

One command, no backslashes (Windows‑friendly):

spl-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb create-token --decimals 2 --transfer-fee-basis-points 100 --transfer-fee-maximum-fee 500 --interest-rate 5 --enable-metadata

Output (yours will differ):

Creating token DrcSSbxxb63GiZiaXd1tFPRwwofFV3pJHSpFY1aCvcjN under program TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
Address:  DrcSSbxxb63GiZiaXd1tFPRwwofFV3pJHSpFY1aCvcjN
Decimals:  2

Save the mint address — we’ll call it $MINT.

Step 2 – Initialize Metadata

spl-token initialize-metadata $MINT "ArcCoin" "ARC" "https://raw.githubusercontent.com/solana-developers/opos-asset/main/assets/CompressedCoil/metadata.json"

Step 3 – Verify All Extensions

spl-token display $MINT

Result (abridged):

Extensions
  Interest-bearing:
    Current rate: 5bps
  Transfer fees:
    Current fee: 100bps
    Current maximum: 50000
  Metadata Pointer:
    Metadata address: DrcSSbxxb63GiZiaXd1tFPRwwofFV3pJHSpFY1aCvcjN
  Metadata:
    Name: ArcCoin
    Symbol: ARC

All three extensions are active ✅

Step 4 – Create an Account and Mint 1000 Tokens

spl-token create-account $MINT
spl-token mint $MINT 1000
spl-token balance $MINT   # 1000

Step 5 – Test the Transfer Fee

Create a second wallet (if you haven’t already):

solana-keygen new --outfile second-wallet.json --no-bip39-passphrase --force
solana airdrop 1 second-wallet.json   # fund for rent

Create its token account and transfer 100 tokens:

spl-token create-account $MINT --owner second-wallet.json
spl-token transfer $MINT 100 second-wallet.json --expected-fee 1 --allow-unfunded-recipient

Check balances:

spl-token balance $MINT                     # 900
spl-token balance $MINT --owner second-wallet.json   # 99

The 1 token fee is withheld in the recipient’s account.

Step 6 – Harvest Withheld Fees

# Find recipient’s token account
spl-token accounts --owner second-wallet.json -v
# Withdraw to your own token account
spl-token withdraw-withheld-tokens YOUR_TOKEN_ACCOUNT RECIPIENT_TOKEN_ACCOUNT

After harvest:

spl-token balance $MINT   # 901 (the fee is yours)

Day 37 takeaway – three extensions working together, no custom program required.

Day 38: Compliance‑Gated Token (Default Frozen)

The Goal

Create a mint where every token account starts frozen. Only the freeze authority can thaw (approve) an account. This is how a regulated stablecoin or KYC‑gated platform works at the protocol level.

Step 1 – Create the Mint with `--default-account-state frozen`

spl-token create-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb --enable-freeze --default-account-state frozen

Output:

Address:  4jC4rjpi5wh1TKd2b8cLyAqFm9a68jmGRF1qPEnkENjm
Decimals:  9

Save as $MINT_FROZEN.

Step 2 – Create Two Token Accounts (Both Will Be Frozen)

spl-token create-account $MINT_FROZEN                # yours
spl-token create-account $MINT_FROZEN --owner second-wallet.json   # second wallet

Step 3 – Try to Mint (Must Fail)

spl-token mint $MINT_FROZEN 100

Expected error:

Error: Account is frozen

✅ The enforcement works – even the mint authority cannot bypass it.

Step 4 – Thaw Your Account (The “KYC Approval”)

First find your token account address (spl-token accounts), then:

spl-token thaw YOUR_TOKEN_ACCOUNT

Step 5 – Mint Now Succeeds

spl-token mint $MINT_FROZEN 100
spl-token balance $MINT_FROZEN   # 100

Step 6 – Transfer to Still‑Frozen Second Account (Must Fail)

spl-token transfer $MINT_FROZEN 50 second-wallet.json --allow-unfunded-recipient

Error: Account is frozen (destination).

Step 7 – Thaw Second Account, Then Transfer Succeeds

spl-token thaw SECOND_WALLET_TOKEN_ACCOUNT
spl-token transfer $MINT_FROZEN 50 second-wallet.json --allow-unfunded-recipient
spl-token balance $MINT_FROZEN --owner second-wallet.json   # 50

Day 38 takeaway – compliance is enforced at the runtime level, not in off‑chain code.

What I Learned

Composability is powerful – you can mix and match extensions like LEGO bricks.
The CLI abstracts complexity – one command sets up TLV‑encoded extension data.
Default frozen accounts are a game‑changer for regulated finance on Solana.
Debugging on Windows requires absolute paths and careful attention to program IDs (the correct one is TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb – note the lowercase z).

Intrest bearing token in solana

NIRANJAN LAMICHHANE — Fri, 29 May 2026 07:48:58 +0000

Create an Interest‑Bearing Token on Solana (Token‑2022) – Step by Step

Learn how to mint a token that earns interest automatically, every second, using Solana’s Token‑2022 program.

No staking, no separate contracts – just a CLI and a wallet.

1. Prerequisites

Solana CLI & SPL Token CLI installed
A funded wallet (devnet/testnet)
Basic terminal comfort

2. Create the Mint (with 5% interest)

The --interest-rate is in basis points (bps).

500 bps = 5% APY.

spl-token create-token \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb \
  --interest-rate 500

Sample output mint address (yours will differ):

CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu

3. Create a Token Account for Your Wallet

spl-token create-account <MINT_ADDRESS> \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

(My created account: 9nSZ154gJQ8H2qzgLV8mk7K5N4LbngViksUyrzsgncn1)

4. Mint 1000 Tokens

spl-token mint <MINT_ADDRESS> 1000 \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

5. Observe the Growing Balance

Check UI balance (applied interest)

spl-token balance <MINT_ADDRESS> \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

Result right after mint: 1000.000362839 – already more than 1000!

Inspect mint metadata

spl-token display <MINT_ADDRESS> \
  --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb

You’ll see:

SPL Token Mint
  …
  Supply: 1000000000000   (raw supply, 1000 tokens with 9 decimals)
  Decimals: 9
  Interest-bearing:
    Current rate: 500bps
    Average rate: 500bps
    Rate authority: …

Key insight: The on‑chain supply never changes.

The UI balance grows because the program calculates interest per second from the last update time.

See raw account data (optional)

solana account <MINT_ADDRESS> --output json

Returns a base64‑encoded blob – that’s where the interest rate and timestamp live.

6. Wait and Watch Interest Compound

After a few minutes, run spl-token balance again.

The number will be larger – without any transaction.

7. Change the Interest Rate

As the rate authority, you can update the rate anytime.

spl-token set-interest-rate <MINT_ADDRESS> 15000   # 150% APY

Check display again – Current rate now shows 15000bps.

Balance will start climbing much faster.

Later I set it to 30000 (300% APY) and balance quickly went to 1000.015285823.

8. Rate Limits

The rate is stored as a 16‑bit signed integer (i16).

Max allowed: 32767 bps (~327.67% APY).

Min allowed: -32768 bps (negative interest, for demurrage tokens).

Trying 35000 or 100000 will error:

error: number too large to fit in target type

My Full Command History (Reference)

spl-token create-token --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb --interest-rate 500
spl-token create-account CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
spl-token mint CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu 1000 --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
spl-token balance CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
# 1000.000362839
spl-token display CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu --program-id TokenzQdBNbLqP5VEhdkAS6EPFLC1PHnBqCXEpPxuEb
solana account CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu --output json
spl-token set-interest-rate CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu 15000
spl-token balance … # 1000.008316801
spl-token set-interest-rate CRXKmUj2dVcJhr6uH5YVduZ352YdUeSxYT2WEvPA66Vu 30000
spl-token balance … # 1000.015285823

Why This Matters

Yield‑bearing stablecoins without external protocols
Automatic savings tokens that reward holders per second
Dynamic rates – adjust APY on the fly based on market conditions
Fully on‑chain, permissionless, composable

Now go build your own interest‑bearing token. Happy hacking! 🚀

Understanding tokenomics of Solana

NIRANJAN LAMICHHANE — Thu, 28 May 2026 06:51:24 +0000

In recent days of #100daysofsolana , i learned worked with transfer-fee-enabled tokens, withheld fees, fee authorities, and Token-2022-specific behavior.

During this , i specifically struggled with creating a standard SPL token account instead of a Token-2022 token account, which result in transactions fail, accounts appear incompatible, and CLI commands behave unexpectedly.

From this struggle , i specifically learnt that :

fees are automatically deducted during transfers,
fees accumulate in token accounts,
withheld fees must later be withdrawn.

Solana Account Model — City Analogy

NIRANJAN LAMICHHANE — Wed, 27 May 2026 07:18:52 +0000

Think of Solana as a city

Every building in the city has the same basic structure: an address, a size, an owner, and contents inside. That is exactly what an account is — a building. The blockchain is the city map that records who owns what building and what is inside each one.

The 5 fields — what every building has

Field	Analogy	Meaning
`lamports`	money inside the building	how much SOL this account holds (1 SOL = 1 billion lamports)
`owner`	who has the master key	only this program can change what is inside — everyone else can look but not touch
`data`	what is stored inside	raw bytes — could be empty (a wallet) or full of state (token balance, game score)
`executable`	is it a factory or a house?	`false` = stores things (wallet, data) · `true` = runs code (a program)
`rentEpoch`	building tax status	pay 2 years rent upfront and you never pay again — that is rent exemption

Why are program and data separate buildings?

1. Ethereum way: imagine a McDonald's where the kitchen (code) and the customer orders (data) are locked inside the same room. To change the menu, you demolish the whole building and rebuild it. Every new franchise needs its own separate building with its own separate kitchen.

2. Solana way: the kitchen (program account) is one permanent building in the city. It never stores any food orders inside — it is just the recipe book and the chef. Every customer order (data account) is a separate locker room next door, owned by the kitchen. Millions of lockers, one kitchen.

The three building types in the city

Wallet account — Your house. You own it.

executable: false
data: empty
owner: System Program
Holds SOL. The System Program is like the city government — it owns all plain wallets but you control yours with your private key (signature).

Program account — A factory. Read-only.

executable: true
data: BPF bytecode
owner: BPF Loader
Pure logic. No state lives here. Once deployed it just sits there waiting to be called. Upgrading means redeploying the bytecode — the data accounts are untouched.

Data account (PDA) — A locker assigned to you.

executable: false
data: your state
owner: the program
Created by the program on your behalf. Stores your token balance, your game score, your profile — whatever the program needs to remember about you. You cannot open it without the program.

One-line rule to remember forever

The owner field is the master key. Only the program listed as owner can change the data inside or take lamports out. Anyone in the world can send SOL in or read the data — but only the owner can write.

Your wallet is owned by the System Program. When you sign a transaction, you are telling the System Program "I authorise this" — and it acts on your behalf because your signature matches your address.

Walk me through a SOL transfer at the account level — which accounts change and which programs act on them.

Solana Transactions: not just a “request/response” ,but “atomic on-chain state changes”

NIRANJAN LAMICHHANE — Wed, 27 May 2026 05:28:51 +0000

In web2 , our rest api call are confined with just request and response framework . In web3 , for this particular solana , our transaction goes through this full commitment lifecycle:

send() → Processed ✓ → Confirmed ✓ → Finalized ✓

State	What it means
Processed	Validator received the transaction
Confirmed	2/3 of stake weight agrees
Finalized	Permanent — cannot be rolled back

sendAndConfirmTransaction() polls internally through all 3 states and resolves once finalized.

Pay to attempt, not just to succeed

Unlike of web2 , on which failed transaction incur nothing ,in web3 , we pay to attempt, not just to succeed. The chain ran the instruction, hit the error, and charged the fee anyway.

During my day 19 of 100 days of solona , I revealed:

Status: Error processing Instruction 0 — custom program error: 0x1

0x1 = InsufficientFunds on the System Program

What the failed tx showed

Field	Value from my terminal
Error code	`custom program error: 0x1`
Fee charged	`0.000005 SOL` (still deducted)
Compute Units	`150` consumed
Balance change	`1.468975 → 1.46897` (fee only)
Log message	`Transfer: insufficient lamports 1468970000, need 500000000000`

Final Note : err.logs vs console.error

	`err.logs`	`console.error(err)`
Source	Solana runtime (on-chain)	Node.js
Tells you	WHY the chain rejected it	WHERE your code broke
Can be undefined?	Yes — if tx never reached the chain	No — always present
Example	`Transfer: insufficient lamports…`	`SendTransactionError: simulation failed…`

Recommendation : Always use both:

} catch (err) {
  console.error("JS error:", err.message);     // WHERE it broke
  if (err.logs) {
    console.log("Chain logs:", err.logs);       // WHY chain rejected
  }
}

This much upto my learning journey for now . Will be updating other blog soon too .

Policy Storyteller: Turning Nepali Bills into Human Stories with Gemma 4

NIRANJAN LAMICHHANE — Mon, 25 May 2026 06:28:32 +0000

What I Built

Policy Storyteller helps Nepali citizens understand laws without a law degree.

Pick a bill → get a plain-language brief, three diverse personas (Terai, hill, city — farmer, student, shopkeeper…), each with a day-in-the-life scenario and what becomes riskier / safer → vote on the story. English or नेपाली.

Four bills built in: Social Media Act 2081, IT & Cyber Security 2082, School Education 2080, Privacy Act 2075.

Not legal advice — digital equity for low literacy and patchy 4G.

Demo

Repo: https://github.com/NiranjanNlc/PolicyStoryTeller

Flow: Choose bill → Generate story (~1–2 min) → Explore brief & personas → Vote. Stories cache in localStorage per bill + language.

How I Used Gemma 4

Gemma 4 does everything — no hand-written summaries, no rules engine. A FastAPI backend chains seven focused calls per story:

Step	Gemma 4 outputs
Brief	JSON: summary, who is affected, key points
Personas	3 diverse Nepali composites
Scenarios	2–3 sentences each, NPR & real places
Risks	JSON: riskier / safer lists

Prompts force Nepal context (Nagarpalika, NPR, Dashain, Terai/hill/mountain) and Devanagari Nepali when selected. Pydantic validates JSON; one auto-retry if the model adds markdown fences.

Via OpenRouter (OpenAI-compatible API) — swap model id in .env.

Which Model & Why

Gemma 4 small (2B/4B) — on purpose.

Civic users are on phones and free tiers. Each job is small JSON or a few sentences — not a 31B reasoning marathon. Seven sequential calls already take ~1–2 minutes; small Gemma keeps that affordable, fast enough, and good enough in Nepali. MoE/dense would be overkill; small Gemma is the tool that can run in Nepal, not just about Nepal.

Stack

React + Vite + Tailwind · FastAPI + Pydantic · OpenRouter · no DB (localStorage + file votes)

cd backend && pip install -r requirements.txt && copy .env.example .env
uvicorn main:app --reload --port 8000
cd ../frontend && npm install && npm run dev

Learned (quick)

Retry on bad JSON beats switching to a bigger model.
Tell Gemma who the reader is (“low legal literacy”) — Nepali output improves a lot.
Run calls sequentially on free tier or you hit 429 halfway through a story.

Links

👉 https://github.com/NiranjanNlc/PolicyStoryTeller

Gemma 4 Challenge — Build With Gemma 4 · Solo · MIT

Disclaimer: Educational composites only — verify with official Nepal Government sources.

NO no Account is not just a database , whose history is traced and logged .

NIRANJAN LAMICHHANE — Mon, 04 May 2026 13:36:21 +0000

In this second week of #100daysofsolana , i got got introduced with the concept of account . I learned it by contrasting with the database of web2 .
However , i am aware that Solana's account model is not replacement for web2 database, rather it's solving a different problem: storing state in a system where no single entity has control, reads are public, and writes require cryptographic authorization.
On Solana, "every account is an open book the moment it exists". You can query any program address on the internet and instantly see its balance, owner, executable flag, and transaction history—no API key, no permission, no credentials.
In a normal app, our code checks if a user is allowed to edit something. On Solana, the system itself blocks anyone except the account's owner from making changes. To update an account, we must prove you own it by signing the transaction.
In a regular database, we can ask for related data with a JOIN. On Solana, accounts cannot query each other. If we need connected information, we fetch each account individually and combine them in your own code. This sounds old‑fashioned, but it's one reason Solana runs so fast.

First experince with programming in web3

NIRANJAN LAMICHHANE — Sun, 26 Apr 2026 11:34:43 +0000

Here , i connect with the devnet of sol with the help of phanthom wallet from browser

Learning of W1 of #100DaysOfSolana

NIRANJAN LAMICHHANE — Sun, 26 Apr 2026 11:27:51 +0000

I always have the thrill and wish for learning and experimenting with the web3 . Scattered tutorial and knowledge over different platform has not contributed significantly in my knowledge building .
So , i decides to enroll and go along with #100DaysOfSolana to bring some sort of structured knowledge in the sector of web3 . Till now , this journey gave me a true eureka moment for understanding different concepts and terminology that I’d heard before but never fully grasped. Let me share three breakthroughs that changed how I see Web3.

1. Public Key vs. Private Key – Not Just a Username and Password
The public key is what others see. They use it to send you crypto or verify that a transaction came from your wallet. In Web2 terms, it’s like a username. But here’s the nuance: Web3 is pseudonymous, not fully anonymous. Your public key is visible on the ledger, but your real-world identity isn’t attached unless you connect it yourself.

The private key, on the other hand, is yours alone. You use it to sign transactions – proving you own the wallet without revealing the key itself. It’s similar to a Web2 password, but with one huge difference: there’s no “forgot password” option. Lose your private key, lose your funds forever. That’s why people write it down on paper or use hardware wallets. This clarity was my first big aha moment.

2. Devnet – The Playground Before the Real Game
For a long time, I wondered: how can developers experiment with cryptocurrency when it has real value and trades live? That confusion vanished when I discovered Solana Devnet.

On devnet, you can request fake SOL for free using a faucet. You can deploy smart contracts, send transactions, and make mistakes without losing real money. It’s a sandbox. Once your code works on devnet, you test again on testnet, and only then do you go to mainnet – the live blockchain. Now I understand that almost every serious blockchain project starts its life on a devnet or testnet. This made programming with crypto feel safe and exciting.

3. Integers, Not Floats – Avoiding the Rounding Nightmare
Another question haunted me: why do blockchains use integers (like lamports for SOL or satoshis for Bitcoin) instead of floating-point numbers?

The answer clicked when I thought about rounding errors. Different machines round floating-point numbers differently – even by tiny amounts. On a public ledger where thousands of nodes must agree on every balance, those tiny differences would break consensus. One node might see 0.1 + 0.2 = 0.30000000000000004, while another sees a slightly different value. Using integers (e.g., 300,000 lamports) guarantees every node calculates exactly the same result. This small design choice is actually a pillar of trust in blockchain.

So , in solana we are using the things of lamports and sol, while the result are being shown in the sol , the underlying calculation all are performed in lamports . For conversion , 1 SOL is always equal to 1,000,000,000 (one billion) Lamports.

Final Thoughts
These eureka moments didn’t come easily . It was with the passion curiosity , dareness to ask the silly question , contigency in the learning , learning from the mistake and resistace to break the thing along making it .

Coffee, Code, and Junie: My Journey to 10x Productivity with JetBrains AI

NIRANJAN LAMICHHANE — Tue, 03 Feb 2026 14:25:59 +0000

Dream of 10x Developer :

I've always chased that mythical 10x developer status—that magical state where code flows like water, bugs vanish before they form, and architecture emerges perfectly from the chaos.But something was holding me back to achieve this .
I'm an IntelliJ evangelist. The keyboard shortcuts are muscle memory, the UI feels like home, and Android Studio is basically family. But every time I tried AI coding assistants, I hit the same wall—they all lived in VS Code's world. The mental context switching was killing my flow state.

At this time , the intelij ide announces this hackathon of the Sky limit , providing myself the free credit and opportunity to try out junie and ai assisted coding .Its like a gift from the coding gods: free access to Junie, an AI assistant built right into my beloved IDE.

Same time , i was starting to learn python and data science too . To get maximum advantage of junie , i install python plugin in intelij ide to give a try to python and data science . Later , i found that Jetbrains have similar product “ Pycharm “ for this purposes.
Enough about me , lets talk about what I built with the help of junie .

I built ScrIM Coach, which is an esports performance analysis tool that transforms raw League of Legends match data into actionable coaching insights. We analyzes professional team performance using the GRID Esports API to identify strategic patterns, execution gaps, and draft weaknesses. We provide executive summary , detailed analysis , practice planning by analyzing the data to the coach . The coach can also print out the action plan from the insight we have constructed .

The project is licenced under MIT license in following source :

You can try out at : here

My Favourite part :

Favourite part of me was the BRAVE MODE. I give complete control over the junie to make changes to the project and its file . After providing prompt , i can have long sip of the coffee , read the hackathon details and submission requirement , while junie have completed the tasks .
I'd write a prompt like 'Refactor this to follow clean architecture with proper separation of concerns,' take a long sip of coffee, watch Junie restructure 15 files simultaneously, and return to a codebase that was suddenly... beautiful. The best part? Nothing broke. Tests still passed. The UI still rendered

Important Contribution :

The most important contribution junie make in my productivity is during the ui enhancement . Being the backend developer and android engineer previously , pixel perfect ui seems to be not my cup of tea. But using junie , i can not only draft , but also implement pixel perfect ui , in many cases , junie does it by itself , what we have to do is attach the screen shot of what went wrong and what is your desired output .

Impressive Refactoring :

The most powerful ability and impressive things about junie for me is its ability to refactor without breaking the functionality and UI . I initially designed the working MVp with some trash architecture without following any pattern and standard . I refactor the whole of my mvp to adhere to solid principle and clean code architecture in the single prompt . Interestingly , nothing breaks at all and i would be able to add new feature after that in more easier and scalable way.

UI Magic for Backend Developers:

The Flow State Achievement:

My workflow was made more smoother and i have attained the flow state during my this journey of hackathon . Adding feature , enhancing functionality were just a prompt away and its debug mode executed by itself makes it produce the code which is actually working .

Most Misused Capability :

Not only i used Junie , I also misused junie , especially in the work of version control . I ordered ( just not prompted) junie to commit the changes it has made with clear commit message and push it to the remote source . Similarly , i often ordered it to combine multiple git commit to the single one and of course , it obey me like a good servant.

Wish it was there :

I wish to make my changes live on my deployed site as soon as i make change in the codebase, because legends debug in production. If inteilij have MCP server support , it would have been few prompt away . Absence of this feature makes me little disappointed at last .

If you're like me—comfortable in JetBrains' ecosystem but curious about AI assistance—take the leap. The hackathon may be over, but the learning isn't. Junie showed me that the future of development isn't about replacing developers; it's about amplifying our humanity through technology.

DEV Community: NIRANJAN LAMICHHANE

From Android Engineer to AI/ML – My Journey and First Realization

My Curiosity

My Discovery

The Sweet Spot (Still Searching)

I Built a Nepal Government Complaint Transparency Bot with Hermes Agent (From Zero, in One Hour )

What I Built

Demo

Code and My Tech Stack

How I Used Hermes Agent

The Setup Journey

The Build

What Surprised Me

Why This Matters for Nepal 🇳🇵

Building Multi‑Extension Tokens on Solana and making it compliance goated

Day 37: The Triple‑Extension Token

The Goal

Step 1 – Create the Mint

Step 2 – Initialize Metadata

Step 3 – Verify All Extensions

Step 4 – Create an Account and Mint 1000 Tokens

Step 5 – Test the Transfer Fee

Step 6 – Harvest Withheld Fees

Day 38: Compliance‑Gated Token (Default Frozen)

The Goal

Step 1 – Create the Mint with --default-account-state frozen

Step 2 – Create Two Token Accounts (Both Will Be Frozen)

Step 3 – Try to Mint (Must Fail)

Step 4 – Thaw Your Account (The “KYC Approval”)

Step 5 – Mint Now Succeeds

Step 6 – Transfer to Still‑Frozen Second Account (Must Fail)

Step 7 – Thaw Second Account, Then Transfer Succeeds

What I Learned

Intrest bearing token in solana

Create an Interest‑Bearing Token on Solana (Token‑2022) – Step by Step

1. Prerequisites

2. Create the Mint (with 5% interest)

3. Create a Token Account for Your Wallet

4. Mint 1000 Tokens

5. Observe the Growing Balance

Check UI balance (applied interest)

Inspect mint metadata

See raw account data (optional)

6. Wait and Watch Interest Compound

7. Change the Interest Rate

8. Rate Limits

My Full Command History (Reference)

Why This Matters

Understanding tokenomics of Solana

Solana Account Model — City Analogy

Think of Solana as a city

The 5 fields — what every building has

Why are program and data separate buildings?

The three building types in the city

One-line rule to remember forever

Solana Transactions: not just a “request/response” ,but “atomic on-chain state changes”

Pay to attempt, not just to succeed

What the failed tx showed

Final Note : err.logs vs console.error

Recommendation : Always use both:

Policy Storyteller: Turning Nepali Bills into Human Stories with Gemma 4

What I Built

Demo

How I Used Gemma 4

Which Model & Why

Stack

Learned (quick)

Links

NO no Account is not just a database , whose history is traced and logged .

First experince with programming in web3

Learning of W1 of #100DaysOfSolana

Coffee, Code, and Junie: My Journey to 10x Productivity with JetBrains AI

Dream of 10x Developer :

My Favourite part :

Important Contribution :

Impressive Refactoring :

UI Magic for Backend Developers:

The Flow State Achievement:

Most Misused Capability :

Wish it was there :

Step 1 – Create the Mint with `--default-account-state frozen`