Forem: snikmas

AI for a month: impressions, mistakes, and what actually worked

snikmas — Fri, 20 Mar 2026 06:58:14 +0000

Two months ago I wrote a post where I was confused: where is the line between programming and using AI for it? What was I supposed to do on my own, and what could I delegate to AI? I felt like if I didn't start using AI right now, I'd miss the train.

During this month I've been doing a lot of stuff with AI — and I'm really enjoying it. I figured out a few patterns: which ways of using AI bore me, which ways I shouldn't use it, and how I can actually use AI to learn.

Takeaway 1: I don't like when AI does everything for me

I don't like the feeling of not understanding what's going on.

There were times when I was tired of a project or just annoyed, and I'd say:

"I don't care how you do it, just do it."

AI can do the work pretty well (in my case it was basics, so there usually weren't many problems). All I had to do was check the result, click buttons, and so on. If I spotted a bug — I'd tell it to fix that too.

But looking back, I don't like that process. It can give you a lot of code you don't understand. Some people are okay with that. Not me. I still want to understand as much as I can.

Takeaway 2: AI is not a programmer — it's a guide, teacher, and product manager

Before, when I wanted to build something and didn't know how to start, I'd just get stuck. Where do I begin? What should the folder structure look like? I'd spend time googling, jumping between tutorials.

Now I just ask. I ask it to help me create a plan, tell me what problems might come up, suggest a stack, suggest a folder structure, or explain how this kind of thing is built in the real world.

For example: I wanted to build a website for my project in Python. Before, I could only think about JS/HTML/CSS. AI introduced me to Streamlit — a small library with limited control, but it was the right fit for that project.

And when I don't know how something works, I ask:

"Explain X as if I'm a complete beginner."

It explains in a Socratic way, so I'm actually learning — not just copy-pasting. I also use this when picking up something new, or I ask it to create a quiz for me.

So that's just about one month of actively using AI — and I think I'm only using 10–20% of its full potential. But I already have a feel for how to use it. I don't feel as lost and frustrated as I did last time.

If things still feel foggy and unclear — there's only one way to figure it out: try it.

Try it, play with it, build with it. After enough hours of experimenting you'll figure out by yourself: which style works best for you, how you like to learn with it, what you want to use it for. But also — don't forget to think critically. Don't take everything AI says as truth. If something feels off or unclear, check it yourself.

What are your takeaways? How long have you been using AI?

Where's the line between programming and using AI?

snikmas — Mon, 26 Jan 2026 15:53:20 +0000

Backstory

I've known about vibe-coding for a long time, but I didn't really get what it actually was. Before, I thought it was just writing your code and asking AI to write some parts for you (like: go to browser → ask → it gives you code → done). Or ask Cursor. Yeah, I thought it worked like that.

I also thought that when you learn new stuff (new stack, new language), best practice is doing everything on your own.

For example: when I learned Java, Python, Spring—I could ask LLMs how this thing works, how that works, but I rarely asked them to write code for me. I also turned off auto-completion in PyCharm/IntelliJ, disabled Copilot, all of it.

And then I was surprised that nowadays... almost nobody does this (or so I think). I have one friend who's genuinely one of the smartest guys I know (like really smart). He started a startup. He was shocked when I told him about my setup—especially turning off auto-completion.

He told me nowadays he barely codes; most of the time AI codes for him. The only thing: he understands what it does. He could write it himself if needed. He was trying to hire interns and got angry: "nowadays most guys can vibe-code, but don't understand what is actually happening."

The problem:

So I've been thinking. What am I supposed to code myself? What should I leave to AI?

Because here's the thing—I can learn to write something myself. Really understand it. But an LLM can write it faster. Probably better. So what's left for me—just debugging LLM output?

But if I'm not writing code, I'm not practicing. I'm not getting better at it. Like: you write every day → more experience → new ideas come. Like a muscle. But if you give this to AI... what happens?

And I'm a CS student with no real experience. I don't know what the rules are anymore. What should I actually be able to do myself? Are there things I don't need to understand deeply anymore?

Before, I thought the answer was simple: be able to write everything yourself. But now guys are just vibe-coding and shipping faster.

My current situation:

I'm working on portfolio projects right now. Never built this type before—lots of steps, 70% I've never learned. Asked AI for a roadmap (steps, what to learn).

Currently I just finished reading about the requests library in Python. It's really easy; I think there's no problem asking AI to write it for me. But I want to try at least once on my own, for practice—to actually check if I understand it or just think I understand it.

Because that's another thing: you can read docs and feel like you get it, but until you write it yourself, you don't know for sure.

So I put a temporary rule for using LLMs:

Read the docs first
Try to code as much as you can yourself If you're stuck: ask the LLM for a hint or a template, not ready-to-use code. Or, if you really understand the problem—give it all the details, describe the whole process so it can write code that you could have written yourself

It's probably not the best approach. Just something I came up with because I don't know what else to do.

So...

Thanks for reading this mess of thoughts!
How are you guys handling this? What do you code yourself, and what do you give to AI?

LeetCode Series: SlidingWindow (3/5)

snikmas — Tue, 23 Sep 2025 11:45:53 +0000

Hi there! I've been busy learning new tech (and again: ended up in "tutorial-loop-hell").

Today, we will learn the sliding window technique — pretty useful and it covers a huge amount of problems on LeetCode.

Sliding Window

See the word substring in a problem? In about 80% of cases, that’s a hint to use a sliding window.

Longest / Maximum / Minimum
Substring / Subarray / Block
... of size k / length k

In some sense, it’s a kind of two-pointers pattern: whenever you deal with consecutive elements, that’s usually a sliding window.

The idea: use two pointers to track a range of elements — that’s your window. You can expand it, shrink it, whatever the problem needs. You only care about the elements inside the window; the rest of the array? You don’t care about it.

Two types of sliding window

Fixed-size window → window size doesn’t change; move the two pointers along the array.
Dynamic window → window can shrink or grow depending on the problem.

General Approach

Initialize leftPtr = 0, rightPtr = 0 (optionally track window length).
While rightPtr < arr.length: 2.1. Expand the window by moving rightPtr++ if your condition allows. 2.2 Shrink the window by moving leftPtr++ if needed.
Process whatever you need inside the window.

Here’s a code example:

Let’s try to solve a LeetCode problem.

643. Maximum Average Subarray I

In short:

an integer array nums
nums length n
integer k
find a subarray of length k with the max average and return it

Approach

A subarray.. of length k? → a sliding window. A fixed-size sliding window.
First, let’s find the subarray with the maximum sum. In the end, divide that sum by k to get the average."

Step 1: Compute the first window (minimum size should be k → it will be our first max).

Step 2: Slide the window — expand and shrink as needed in each iteration. Create a sum variable equal to our max. While sliding, update sum and compare it with max.

Step 3: In this problem, they ask us to return a double. Okay, return it and don’t forget to divide by k — they still ask us for the average.

Code

Time: O(n) - no brute force with O(n^2)
Space: O(1) - we don’t need any data structures

Summary - Key Points to Remember

Sliding Window = a two-pointer technique for problems involving consecutive elements.
Common keywords: longest, maximum, minimum, substring, subarray, block, “of size k”.
Two types: Fixed-size and Dynamic window
General approach:
Start with left = 0, right = 0.
Expand window by moving right.
Shrink window by moving left if needed.

That's all for today!

In the next 2 sections, I’d like to explain two topics that are also a bit hard for me (they also require knowledge of trees and graphs). It will be challenging, but also pretty interesting! See you next time /smile/

When a Simple Project Becomes a Terminal Debugging Nightmare

snikmas — Sat, 13 Sep 2025 13:02:33 +0000

Hello, today I wanna start with my news:

I’ve finally finished my uni-project: Dictionary 🎉

Well, in the beginning it wasn’t hard: create a menu, let the user choose some options, give them an input to translate, send it to some API, get the result and output it.

Pretty easy, doesn’t it? Okay, let’s add “save” and “history” options. Well, the terminal version looks a little boring… just like:

Not good. I want pictures! I want cute animations! … that’s how I came across ncurses.

That’s how it went from an enjoyable — moderately hard program — to a super hard program that you have to debug for days.

My process:

1. Dictionary

I had to find a dictionary to translate words. There were 2 options: offline and online. I wanted experience with online APIs, so I naturally chose the online version.

Next, what to use? I wondered:

Online translators (Google/Baidu — a Chinese Google) are paid + many western sites don’t work well in China. This project is for my professors, so I wanted them to run it without problems.
DeepSeek — well… it doesn’t have a public API.

When I thought that was over, by chance, I found a Chinese translate AI API: Youdao AI Translate (be careful: fully in Chinese).

Good! I could still do my project. Onward: write code.

2. Coding the foundation

The root idea was pretty simple. I think I finished it in ~3–4 days:

Menu: translate with 2 modes: CN→EN and EN→CN; history; saved words; exit
Data structure: store word in English, word in Chinese, and isFavorite
- At first, I wanted to add transcription/pinyin, but that requires more requests… well, basics first, maybe later.
- Used linked lists for saved/history words
Create API request: challenging, but I liked it:
- curl
- uuid
- openssl
- cJSON (totally different than JavaScript)

Actually, I didn’t want to use curl at first: I tried sending requests myself using a proxy…

But that added too much complexity. At that time, I didn’t fully understand what kind of program this would be, so I chose curl. Proxy can wait for next time.

The app was ready and worked well.

3. Enter ncurses

Oh, here we are. My enjoyable program became my most hated program — rewriting the whole structure 2–3 times.

What happened?

I wanted to add mascots. Stored in double-linked lists.
Iterating through double lists using pointers — one more class for me.
Connection issues: I use VPN in China. Sometimes it threw unexpected errors.
OS: originally Linux program. On Windows (thanks WSL 🙏), still unexpected behaviors sometimes.
Fonts in Chinese: Unicode, not ASCII. Terminal didn’t support Unicode initially. After hours, sometimes I saw characters; next day, garbage.
Reorganized folder structure: initially ncurses in one file, logic in another. Here're we go again: Messy spaghetti code started.
Ncurses windows: every window has coordinates. Had to track x, y carefully. Thanks, linear algebra classes!
Buffer nightmare: scanf leaves \n, ncurses windows also have buffers. Had to clear them every time.

Of course, I used ChatGPT for help. Just guidance. Not full copy-paste... Sometimes:

I didn’t understand a bug →
Ask ChatGPT →
Read explanation carefully →
Try code/copy →
Doesn’t work → repeat 5+ times

In the end, I couldn’t understand anything, so I rewrote everything in a new file. Frustrating, but totally worth it.

4. Final thoughts

I finished the last line, ran it, and thought: GOOD ENOUGH, I FINISHED IT!

Then debugging time began… Makefile helped a lot, but imagine all the errors it showed: malloc issues, missing headers, wrong function order. 😅

Summary

Even though it was harder than expected, I really like this project (even if it’s still buggy). I learned a lot:

Sockets, SSL/TLS, OpenSSL, UUID: handling internet requests in C and understanding the differences between Windows and Linux. Big thanks to Ed Harmoush (@PracticalNetworking) and Jacob Sorber (@JacobSorber)! I learned all the topics mentioned above from their YouTube tutorials, which were really helpful for my project 😄
cJSON: JSON parsing in C.
Error handling – malloc/pointers issues, input buffers, ncurses buffers (it was hard)
ncurses – terminal UI and animations
Linked lists, data structures, buffers: deeper understanding.
Makefile: first time learning automated compilation.
README: writing a clean, portfolio-ready GitHub page.

This project taught me patience, debugging, and how to bring a terminal program to life. And most importantly — I still love it ❤️

If you’ve read until this line — wow, thanks for your time! I really appreciate it 😅

LeetCode series: Two Pointers (2/4)

snikmas — Fri, 12 Sep 2025 15:26:11 +0000

LeetCode and Two Pointers

Hi, Nice to see you! I hope you’re doing well 😄

Today we will learn the Two Pointers technique, a simple yet powerful strategy for traversing arrays or strings.This is must have for solving problems in LeetCode.

Two Pointers

Use two indices (pointers) to traverse a data structure.
The pointers don’t have to move in sync — it depends on the problem.
Common types:
1. Opposite ends (start and end of array/string)
2. Same direction (slow/fast pointer)
3. Expanding around the center
Common goals:
- meet in the middle (palindrome check; opposite ends)
- move at different speeds (fast/slow pointer, same direction)
- merge two sorted array

In short: choose two indices, check conditions while iterating, and move pointers as needed.

Features:

In most cases, it requires a sorted array
Time Complexity: O(n) or O(log n) (depending on the problem)
Space Complexity: O(1). pretty good
Pretty basic but fundamental, that also can be used for another techniques (sliding window)

Where to use?

Text analysis: palindromes, substrings, symmetry.
Removing duplicates from arrays.
Searching or filtering data efficiently.

As you can see, this is a must-have technique. It’s not only useful for solving LeetCode problems but also very practical in real-world jobs.

Okay, that’s enough. Let’s practice

Problem: 125. Valid Palindrome

In short: given a string, determine whether it is a palindrome.

Ignore punctuation, spaces, and symbols.
Case doesn’t matter ("S" and "s" are the same).

Take 2-3 minutes to think about how to use the two pointers technique to check if a word is a palindrome:

A palindrome is a word/number/sentence that reads the same forwards and backwards.

Think of it as an array that is the same forwards and backwards.

Any ideas?

Approach

For problems that check palindromes, using two pointers from opposite ends solves about 80% of them.

Steps:

Set two pointers at the ends of the string
Iterate from the ends to the center using a loop: while leftPtr < rightPtr
Skip everything except letters and digits
Compare the characters ignoring case
Move pointers: leftPtr++(forward) and rightPtr— (backward)
If no mismutch is found: return true → the string is a palindrome, Congrats! You got it!

Code

class Solution {
    public boolean isPalindrome(String s) {
        // two pointers: opposite ends
        int left = 0, right = s.length() - 1;

        while(left < right){
            while (left < right && !Character.isLetterOrDigit(s.charAt(left))) {
                left++;
            }
            while (left < right && !Character.isLetterOrDigit(s.charAt(right))) {
                right--;
            }
            if(Character.toLowerCase(s.charAt(left)) != Character.toLowerCase(s.charAt(right))){
                return false;
            }

            left++;
            right--;
        }

        return true;

    }

Time: O(n)
Space: O(1)

Example:

given: String s = “We panic in a pew!”

Steps:

Input: "We panic in a pew!"
left = 0 → 'W' (letter)
right = 17 → '!' (skip non-letter → move to 'w')
Compare 'W' and 'w' → match → move pointers inward
Continue comparing 'e' and 'e', etc.
All matches → return true → the string is a palindrome

Summary – Key Points to Remember

The two pointers technique is a useful method to traverse arrays or strings, especially for tasks like checking palindromes, removing duplicates, or searching efficiently.
In most cases, the array should be sorted for optimal use (though this is not always required).

That’s all for this article.

In the next section, I will introduce another technique: sliding window (which also uses the two pointers concept).

Explaining all types of problems for each case would take a lot of text (even for this topic—we haven’t explored checking duplicates yet). I may write another article where I select some problems and briefly explain their approaches.

Also, I want to try to include diagrams, because I know how hard it is to read long text without any visuals 😄

Thanks for reading, and see you next time!

LeetCode series: Data Structures (1/4)

snikmas — Mon, 08 Sep 2025 13:27:44 +0000

LeetCode and Data Structures

Hi! 👋 Currently, I’m preparing for my internship next year, and these days I’m working hard on LeetCode problems.

At first, I thought it was enough to just:

Try solving a problem
Check the solutions
Understand the idea
Try it again

Well… it works. But honestly, you’ll be faster (and way less frustrated) if you know some common patterns.

In the next few posts, I’d like to write a series about the most popular techniques that can help you solve about 60–70% of problems on LeetCode (easy → medium level).

In this post, I want to introduce some basic data structures. Once you figure out how these work, you’ll be able to understand most of the others much more easily.

What’s a data structure?

A data structure is just a way to efficiently store data. That’s it.

But it’s really important to choose the right one for the right task. Otherwise, you’ll waste time (and get frustrated) trying to figure out which operations make sense for the structure you picked — or why your time complexity suddenly jumps to O(n^2) just because you tried to add a few characters to a string.

1. Array

String[] myFamily = {"Rick", "Morty", "Summer", "Beth", "Jerry"};

Array is a linear, continuous data structure used for storing data.

Most common example: think about a row of lockers with numbers (indices). You open one and put your data inside.

Some features:

Strings are arrays of characters.
Access time: O(1) → you know your locker, just open it and get your value. mmm, nice, love it.
Insert/Delete at the end/start: O(1)
Insert/Delete in the middle: O(n) (not n^2, so not terrible — just shift N elements).

Where to use:

Traversing a structure in order
Accessing specific indices
Comparing elements from both ends
Sliding window, prefix sum, etc.

2. String

String heroName = "Morty";

Well, strictly speaking, string is not a data structure, but it deserves to be mentioned.

A string is basically an array of characters.

Main things to remember:

In memory, a string really is an array of characters.
Immutable in most languages: for example, when you do "dog" + "s", it doesn’t change the first string — it creates a totally new one.

When to use it:

Checking for anagrams
Returning a substring that matches a pattern
Finding the longest substring without repeating characters
String problems are not for brute-force solutions — you’ll need smart techniques.

3. Set

HashSet<Integer> mySet = new HashSet<>();
mySet.add(0);
mySet.add(1);
mySet.add(6);
mySet.add(5);

Set is a collection of unique variables. That’s it.

Some features:

Access time: O(1) (usually)
Stores only unique elements

Where to use it:

When you need uniqueness
When you want to check for existence
When you need fast membership checks (Array needs O(n), Set does it in O(1))

4. Map (Dictionary)

HashMap<String, String> contacts = new HashMap<>();
contacts.put("me", "123-123-123");
contacts.put("dad", "000-000-000");

A map is a collection of key–value pairs. Like a phone book: name → phone number.

Features:

Access: O(1) (usually); worst case is O(n) but rare
Keys must be unique

Where to use it:

Counting frequencies
Caching
Mapping indices

Summary

That’s it for the basic data structures.

All the others (trees, graphs, linked lists, etc.) are like upgraded versions of these four. If you nail these, you’ll pick up the rest much more easily.

In my next posts, I’ll cover common patterns and real LeetCode problems.

I hope you liked this post — see you later! 👋