Forem: Mari

A Simple Guide to Cookies in Modern Web Development

Mari — Wed, 14 Jan 2026 05:22:37 +0000

If you have ever logged into a website and found that you were still logged in the next day, you have used a cookie. But what is it actually?

As we move through 2026, the way we store data on a user's computer has changed. Whether you are building your first website or your fifty-eighth, here is a guide to how cookies work today and why they still matter.

What exactly is a Cookie?
Think of a cookie as a digital luggage tag. Imagine you go to a hotel to drop off your bags:

The Drop-off: You give your bags to the clerk.

The Ticket: The clerk gives you a small numbered ticket.

The Return: Later, you come back. You do not have to explain who you are. You just show the ticket.

The Match: The clerk looks at the number and gives you your bags.

In this story, the ticket is the cookie. It is a tiny piece of text that the website gives your browser so it can remember who you are later.

How the Process Works (Step-by-Step)
To understand cookies, you have to see the back-and-forth conversation between your computer and the website.

The Request: You type website.com and hit enter. Your browser asks the website for the page.

The Response: The website sends the page data. Along with that data, it sends a note that says: Set-Cookie: ID=123.

The Storage: Your browser sees that note and saves the ID 123 in a small file on your computer.

The Next Visit: The next time you click a link on that site, your browser automatically attaches a note to your request: Cookie: ID=123.

The Recognition: The website sees the ID, looks it up in its database, and says, "Welcome back, User 123!"

Cookies vs. LocalStorage
Developers often get confused about which one to use. Here is the simple breakdown:

Cookies: These are tiny. Their main job is to be sent back and forth between the browser and the website server. They are designed for security and identifying who you are.

LocalStorage: This is much larger. It stays on your browser and is never sent to the website automatically. It is designed for saving settings like "Dark Mode" or a draft of a message.

The Rule: Use cookies for anything sensitive (like a login). Use LocalStorage for things that are not secret.

The Modern Security Rules
In the past, cookies were simple. Today, they have "bodyguards" called attributes. If you do not use these, your website is at risk.

HttpOnly (The Invisible Shield)
When you mark a cookie as HttpOnly, it means the website's own code cannot see or touch the cookie. Only the browser can send it to the server. This prevents hackers from stealing your login information using malicious scripts.
Secure (The Enforced Lock)
The Secure attribute tells the browser to only send the cookie if the connection is encrypted (HTTPS). This prevents people from "eavesdropping" on your data when you use public Wi-Fi.
SameSite (The Border Control)
This attribute tells the browser whether to send the cookie when you click a link from a different website. Setting this to Lax is the modern standard. It prevents other websites from tricking your browser into performing actions you did not intend.

Common Mistakes and How to Fix Them
The Localhost Problem
Many developers turn on the Secure flag and then wonder why their login stopped working on their personal computer. Since your local computer usually does not use an encrypted connection, the browser blocks the cookie. You should only turn on the Secure flag when your website is live on the internet.

The 400-Day Limit
Browsers now have a strict limit on how long a cookie can live. Even if you tell a cookie to last for 10 years, the browser will delete it after about 13 months (400 days). To keep a user logged in longer, you must give them a fresh cookie every time they visit.

The Missing Connection
If you use code to talk to your server, you might notice the cookies are missing. You must tell your code to "include credentials" in your settings. Otherwise, the browser thinks you want to keep your cookies private and will not send them.

Summary: Your 2026 Strategy
To keep your users safe, follow this simple plan:

For Login Sessions: Use a Cookie. Turn on the HttpOnly, Secure, and SameSite settings.

For UI Preferences: Use LocalStorage. It is faster and does not send extra data to the server every time you click a button.

By following these steps, you protect your users while keeping your website fast and easy to use.

The Intersection of web2 backend and web3

Mari — Thu, 18 Dec 2025 21:16:45 +0000

The Intersection of Web2 Backends and Web3

Web3 is often described as a complete replacement for Web2. In practice, that idea breaks down very quickly once real products, real users, and real scale are involved. Most successful Web3 applications today are not purely decentralized systems. They are hybrids, combining traditional Web2 backends with blockchain-based infrastructure.

Understanding this intersection is critical for backend developers who want to move into Web3 without abandoning everything they already know.

This article explores what actually happens at the boundary between Web2 and Web3, why it exists, and how backend engineers fit into the picture.

Why Web2 does not disappear in Web3

Blockchains are excellent at a few specific things. They provide trust minimization, censorship resistance, a transparent state, and permissionless execution. They are not good at fast queries, private data storage, complex computations, or frequent logic changes.

Web2 backends solve those exact problems.

That is why Web3 systems still rely heavily on traditional servers, databases, APIs, and background workers. The goal is not to replace Web2, but to reduce how much trust users must place in it.

In most production systems, Web2 handles speed and usability, while Web3 handles ownership and trust.

What stays Web2

In a typical Web3 application, the following components almost always remain off-chain:

User profiles and preferences
Authentication layers beyond wallet ownership
Complex business logic
Analytics and reporting
Search and filtering
Caching and performance optimization
Notifications, emails, and messaging
Admin and moderation tools

Blockchains are slow, expensive, and public by design. Anything that requires privacy, flexibility, or scale belongs in a traditional backend.

What becomes Web3 aware

At the intersection, the backend begins to understand blockchain concepts and treat them as first-class data sources.

Instead of usernames or emails as primary identifiers, the backend works with wallet addresses.
Instead of database rows as the source of truth, it verifies on the on-chain state.
Instead of internal events, it reacts to smart contract events.

The backend does not own a critical state anymore. It mirrors, indexes, and responds to it.

A common hybrid architecture

A very common Web2 plus Web3 flow looks like this:

A user connects a wallet on the frontend
The user signs a message
The backend verifies the signature
The backend creates a session or token
The backend listens for blockchain events
The backend updates its database accordingly

This approach allows applications to remain fast and user-friendly, while still relying on cryptographic proof of ownership.

The backend developer’s role in Web3

Despite popular narratives, Web3 companies hire a large number of backend engineers. The responsibilities simply expand.

Backend developers in Web3 often:

Verify wallet signatures
Index blockchain data into databases
Listen to smart contract events
Trigger off-chain workflows
Aggregate data across multiple chains
Expose REST or GraphQL APIs
Prevent abuse and automate moderation
Integrate with external services

In many startups, the majority of the codebase is still Web2.

Smart contracts versus backend logic

One of the most important design decisions in hybrid systems is deciding what lives on chain and what stays off chain.

Smart contracts should be minimal, deterministic, and security-critical. They define ownership, value transfer, and irreversible actions.

Backends should handle logic that changes frequently, requires heavy computation, or depends on private data.

Pushing too much logic on the chain leads to high costs and inflexibility. Pushing too much logic off-chain weakens trust guarantees. The intersection exists to balance both.

Tools commonly used at the intersection

On the Web2 side:

Traditional backend frameworks
Relational databases
Caching layers
Message queues
REST and GraphQL APIs

On the Web3 side:

Blockchain RPC providers
Wallet signature verification libraries
Smart contract event listeners
Indexing services

The backend acts as the glue that connects these worlds.

Real-world examples

DeFi platforms store funds and rules on-chain, while backends track positions, history, and risk metrics.

NFT platforms keep ownership on chain, while metadata, search, and discovery live off-chain.

DAO tooling runs voting on chain, but analytics, dashboards, and permissions are handled by backends.

Very few production systems are fully decentralized end-to-end.

Why this intersection matters

Pure Web3 systems struggle with usability and scale.
Pure Web2 systems struggle with trust and transparency.

Hybrid systems combine the strengths of both.

For backend developers, this intersection is an opportunity rather than a threat. Existing skills in APIs, databases, security, and system design are not obsolete. They are essential.

Learning how blockchains work allows you to build systems that are fast, trustworthy, and practical.

The future of Web3 is not about abandoning Web2. It is about integrating it intelligently.

Why Every Generation Has a Different Relationship With Technology

Mari — Fri, 12 Dec 2025 07:37:45 +0000

Every generation carries a different story about the world. A different memory. A different way of surviving and understanding life. That is why no two generations approach technology the same way. Technology did not meet us equally. It did not arrive at the same stage of our lives. It did not shape our beliefs in the same way.

For some, technology was a shock. For others, it was a miracle. And for those growing up today, technology is simply the world they were born into.

The Generation That Watched the World Transform

Older generations lived through a time when technology was not everywhere. Phones had limits. Information requires effort. Connection requires presence. To them, technology is still something to be managed and approached with caution. They had to adjust to it. They had to learn it. They had to trust it slowly.

This relationship is built on distance. They remember what life looked like before everything became fast. Before everything became digital. Before everything became automated. Their memories give them a different kind of balance.

The Generation That Grew Up in Transition

Then there is the generation that grew up in the middle. They saw the world shift from analog to digital right in front of their eyes. They watched phones evolve. They watched the internet spread. They watched opportunities multiply. To them, technology is both familiar and new. Both exciting and overwhelming. Both empowering and distracting.

They understand life before and after the revolution. They understand the silence before everything became loud. They understand the simplicity before everything became optimized. Their relationship with technology is a blend of curiosity and caution because they have lived on both sides.

The Generation Born Into the Digital World

For today’s younger generation, technology is not an invention. It is a foundation. It is the first language they learn before they even understand their own thoughts deeply. They navigate screens before they know how to write fully. They find answers online before asking questions offline.

Their relationship with technology is natural. It is not a tool. It is a lifestyle. It shapes their identity, their friendships, their worldview, and their expectations. It becomes the lens through which they see the world.

Why These Differences Matter

Different relationships with technology create different beliefs. Different fears. Different values. Different strengths.

One generation values privacy because they lived without the internet. Another generation values speed because they witnessed the rise of efficiency. The youngest values access because they have never seen a world without it.

This is not a conflict. It is a spectrum. Each generation brings something the others do not have. Wisdom. Adaptability. Curiosity. New vision.

When these perspectives come together, technology becomes more human. More grounded. More meaningful.

Technology Is Not Just Devices. It Is Culture.

In the end, the story of technology is the story of people. How we adapt. How we learn. How we evolve. Technology shapes our behavior, our communication, our careers, our relationships, and even our definition of community. But each generation interprets these changes through its own history.

This is why we misunderstand each other sometimes. This is why our expectations differ. This is why our comfort levels are not the same. But instead of seeing these differences as a division, we should see them as an advantage.

Technology grows best when many perspectives shape it. When the people who remember life before the internet meet the people who cannot imagine a world without it. When experience meets innovation. When memory meets possibility.

Every generation brings something essential to the digital world. And that is what keeps technology human.

The Silent Pressure of Staying Relevant in Tech

Mari — Mon, 01 Dec 2025 12:59:50 +0000

There is a kind of pressure in tech that nobody really talks about. It is not the pressure of deadlines or difficult tasks. It is the quiet fear that if you stop learning for a moment, the industry will leave you behind.

Every week, there is a new framework. Every month, there is a new tool. Every year, there is a new trend that everyone claims will “change everything”. And in the middle of all of that noise is you, trying to learn, build, grow and still breathe.

The Pace Is Exhausting

People outside tech sometimes believe developers enjoy every update. They think we spend all day exploring new tools for fun. But the truth is simpler. Most of us just want to be good at our work. We want to build things that matter. Yet the landscape moves so fast that even when you are doing your best, you can still feel behind.

You learn a framework today, and by the time you finally understand it, another one is already taking over the conversation. You master a tool only to hear that there is a “better” one you should be using. You start a course, and midway through it, a new update makes half of the syllabus feel old.

The pressure is not loud. It is quiet. It sits at the back of your mind. It pushes you when you are tired. And sometimes, it whispers the thought nobody wants to admit: “Maybe I am not keeping up.”

The Emotional Weight That Follows

This pressure shows up in small ways.

You feel guilty when you take a break.
You feel insecure when you see people posting new projects on social media.
You feel anxious when you realise you have not learned something “important” yet.
You feel overwhelmed when your to-learn list grows longer than your to-do list.

And even though everyone around you seems to be moving forward, you feel like you are running just to remain in the same place.

Why It Happens

Tech is built on speed. Companies build fast. Tools evolve fast. People share fast. That speed can create a culture where slowing down feels like failure. But the truth is this: nobody can learn everything. Nobody can keep up with every update. Nobody can master every tool.

The industry moves fast, but humans do not. And that is fine.

How to Navigate Without Losing Yourself

What helps is not trying to learn everything. What helps is learning with intention.

Keep your focus small.
Pick one path and grow there.
Choose depth over hype.
Let your learning be guided by what you want to build, not by what the internet is shouting about.

You will always see new tools. You will always see new trends. But you do not need to chase all of them. You only need to understand the ones that move you forward.

And remember to rest. You are not falling behind when you breathe. You are not losing your place when you pause. You are simply giving yourself space to grow more healthily.

A Simple Truth

Tech might move quickly, but your career is long. The goal is not to catch everything. The goal is to remain grounded, consistent and intentional.

You do not need to learn like the internet is on fire. You only need to learn at a pace that keeps you human.

The AI-Human Collaboration Every Developer Needs to Understand

Mari — Mon, 24 Nov 2025 13:35:58 +0000

Artificial Intelligence isn’t here to replace developers, at least, not yet.

The real question isn’t “Will AI take my job?” It’s “How can I collaborate with AI to become a better developer?”

AI is already changing how we write code, debug, and solve problems. But to truly benefit from it, we need to rethink workflow, decision-making, and trust. AI isn’t just a tool—it’s a partner, and the way we collaborate with it will define the next era of software development.

AI as a Productivity Partner, Not a Replacement

AI shines at automating repetitive tasks. It can generate boilerplate code, suggest test cases, or even draft documentation. These small efficiencies can save hours each week.

But automation is not intelligence. Humans still decide:

Which problems to solve

Which solutions fit the context

How to weigh trade-offs

When a system is “good enough”

In practice, AI accelerates development, but humans guide it. It’s a partnership.

Example:
Imagine building a booking API. An AI tool might generate serializers, validators, or endpoint templates. But only you can determine whether the design aligns with your architecture or business logic. AI provides options—you decide the direction.

Rethinking Workflow With AI

Collaboration with AI requires a shift in how we approach tasks:

Idea First, Code Later
AI works best when it understands context. Define the problem clearly before asking it to generate code.

Iterative Feedback Loops
Treat AI like a junior developer: generate a solution, review it, refine it, and repeat.

Focus on Higher-Level Thinking
With AI handling repetitive work, humans can concentrate on system design, scalability, and maintainability—areas AI struggles with.

Trust But Verify
AI outputs are not flawless. They can hallucinate, make assumptions, or introduce insecure patterns. Verification and testing remain human responsibilities.

Decision-Making in an AI-Augmented World

AI doesn’t replace judgment—it shifts it.

Trade-offs: AI may suggest the fastest solution, but not the most maintainable.

Ethics: AI can inadvertently introduce bias or insecure practices. Developers must evaluate consequences.

Creativity: AI generates ideas, but humans determine which solutions are novel or valuable.

Collaboration is about amplifying human intelligence, not surrendering it.

Building Trust With AI

Effective AI-human collaboration depends on trust:

Understand AI’s limitations

Be consistent in prompts and review processes

Treat AI as a partner, not an executor

Maintain accountability—humans are ultimately responsible for the code

The stronger your trust framework, the more productive and safe your collaboration becomes.

The Future Isn’t AI vs Human—It’s AI + Human

Developers who embrace AI as a collaborator will:

Work faster

Produce cleaner, more maintainable systems

Focus on high-value decisions instead of repetitive tasks

Those who fear AI may waste time fighting automation or doing work that machines could handle. The reality is simple: AI augments, it doesn’t replace.

The real skill is learning how to collaborate with AI while preserving human judgment, creativity, and responsibility.

Key Takeaways

Stop asking whether AI will replace you. Start asking:

How can AI help me make better decisions?

How can AI reduce friction in my workflow?

Where do I need to remain vigilant and human?

AI-human collaboration isn’t a future concept—it’s already here. Developers who understand it will define the next generation of software development.

How to avoid procrastination as a developer

Mari — Mon, 17 Nov 2025 13:46:47 +0000

Procrastination is one of those things nobody warns you about when you start learning how to code. People talk about choosing a programming language, understanding algorithms and building projects, but nobody talks about the days when you simply do not have the strength to start.

I have learned that procrastination is not just a habit. It is a feeling. It is that quiet heaviness that sits in your chest when you know what to do but you cannot bring yourself to do it. And the most painful part is that only you can stop it.

As developers, we enter every new year with goals. You tell yourself that you will finish this course. You will build that project. You will improve a skill. You will finally be consistent. But somewhere along the line, something shifts.

You start feeling stuck.
You start feeling behind.
You start feeling like you are not good enough.
And slowly procrastination becomes a comfortable hiding place.

You say things like
I will code later
I will continue that course later
I will fix that error later

In reality, nothing is wrong with you. You are simply overwhelmed. And overwhelm is the fastest way procrastination grows.

So how do you break out of it as a developer?

The first step is clarity. Most developers do not procrastinate because the work is hard. They procrastinate because they do not know the next small step to take. When your task is too big, your mind rejects it. But when the first step is clear, your mind begins to move.

The second step is simplicity. Stop trying to learn ten things at once. Pick one skill and stay with it until you can explain it without thinking twice. When your learning path is simple, your consistency increases.

The third step is momentum. Not motivation. Motivation comes and goes. But momentum grows when you show up even when you do not feel like it. Write a small function. Debug one line. Read one chapter. The goal is to move, even if the movement is small.

The fourth step is honesty. Be honest with yourself about why you are delaying. Are you scared? Are you confused? Are you exhausted? Once you know the real reason you are avoiding the work, solving it becomes easier.

The fifth step is environment. Your environment controls your discipline. A noisy workspace produces a noisy mind. Clean your space. Close unnecessary tabs. Give your brain room to think.

Being a developer means dealing with uncertainty. You will always have one bug you do not understand and one new concept you are still trying to wrap your head around. That is normal. That is the job. But you cannot let that uncertainty turn into procrastination.

Consistency is not built on big wins. It is built on small steady steps that accumulate with time. You do not have to be perfect. You just have to start again.

How I organize my VS Code for Maximum Productivity

Mari — Mon, 10 Nov 2025 11:12:56 +0000

Visual Studio Code is one of the most flexible editors out there, but the real magic happens when you make it work your way. After trying different setups and tools, I’ve built a simple VS Code workflow that keeps me productive, focused, and less distracted.

Here’s how I organize my VS Code environment for maximum efficiency as a backend developer.

Keep the Sidebar Clean

I only keep the Explorer, Source Control, and Extensions views pinned. Everything else stays hidden until I need it. A cluttered sidebar slows me down, so if it doesn’t directly help me write or manage code, it’s out of sight.

For quick navigation, I use Ctrl + P to jump to files instantly. It’s faster than scrolling through folders.

Workspaces Over Folders

Instead of opening individual folders, I use VS Code Workspaces.
Workspaces let me manage multiple related projects together and remember settings like themes, extensions, and formatting rules per project.

For example, my Django and API projects have different linters and interpreters, and workspaces make that possible without conflicts.

Extensions That Actually Help

I keep my extensions minimal but powerful. Here are the essentials that make a real difference in my daily flow:

Prettier: Automatic formatting that keeps my code consistent.

GitLens: Makes version control easier to understand at a glance.

Pylance: Improves autocompletion and type checking for Python.

Error Lens: Highlights issues directly in the editor, so I catch them early.

Todo Tree: Keeps track of unfinished work through my TODO comments.

I regularly disable or uninstall extensions I no longer use, and performance improves noticeably.

Terminal Inside VS Code

I stopped switching between my terminal and editor. The integrated terminal is always open at the bottom of my screen.
For backend development, this saves time when running Django servers, managing virtual environments, or testing scripts.

Themes and Fonts Matter

A comfortable theme is not aesthetic — it’s functional.
I use a light theme during the day and a dark one at night. My current setup is One Dark Pro with Fira Code font (for clean ligatures). It reduces eye strain and makes code blocks easier to scan.

Auto Save and Format on Save

This might sound small, but turning on Auto Save and Format on Save prevents countless errors and lost changes.
It also helps when switching between branches or testing code quickly; everything stays consistent.

Keybindings for Speed

Custom shortcuts are the secret to fast navigation.

Ctrl + B → Toggle sidebar

Ctrl + ` → Toggle terminal

Ctrl + / → Comment or uncomment code
These small tweaks save seconds, but over time, they add up.

In Conclusion

Your VS Code setup should reflect how you think and code. The goal isn’t to install every extension available — it’s to build a workspace that reduces friction and keeps you in flow.

Once you personalize VS Code to your habits, you’ll spend less time managing tools and more time writing code that matters.

How to design a database like a developer:A begineer's guide to data planning

Mari — Wed, 05 Nov 2025 10:09:17 +0000

When most beginners start building projects, they rush to open their editors and start coding. They create models or tables without first asking the most important question, What am I really building?

The truth is, good backend developers don’t start from code. They start from structure, and that structure begins with database design.

In this article, I’ll walk you through how to design a database the way a developer does, by thinking about entities, relationships, and constraints before writing a single line of code.

Start with the Problem, Not the Tables

Before you design a database, pause and think about what problem your application solves.

Every database exists to serve a purpose. If you don’t know that purpose clearly, your schema will collapse once your app grows.

Ask yourself:

.What kind of system am I building?

.Who will use it?

.What data do they create or interact with?

For example, imagine you’re building a simple booking system. Your first instinct might be to create a “Bookings” table — but slow down. A booking system involves users, rooms, payments, and schedules. Each of those will eventually become part of your database structure.

Identify Your Entities

Entities are the real-world “things” your app needs to keep track of.

Think of them as nouns: User, Product, Order, Task. Each of these will eventually become a table in your database.

For example, in a task management app, your main entities could be:

.User – someone who owns tasks

.Task – something the user needs to complete

At this stage, you’re not worrying about columns or types. You’re just identifying the main objects that exist in your system.

Define Relationships Between Entities

Now that you have your entities, the next step is to connect them.

Databases are about relationships, how one piece of data interacts with another.

Here are the three main types you’ll use:

.One-to-One: A user has one profile.

.One-to-Many: A user can have many tasks.

.Many-to-Many: A product can appear in many carts, and a cart can have many products.

If you were designing the task manager mentioned earlier:

One user → many tasks
That’s a one-to-many relationship.

It’s helpful to draw this out using an ER (Entity Relationship) diagram, even a simple sketch helps visualize the connections.

Define Attributes for Each Entity

Every entity needs details, and those details become your table columns.

Let’s continue with the task manager example:

User
.id
.name
.email

Task
.id
.title
.description
.completed

user_id (to connect each task to its owner)

At this point, you’re essentially describing what each entity knows about itself.

Apply Constraints and Rules

Constraints are what keep your data clean, organized, and meaningful.

They define the rules your database follows — rules that prevent duplicate entries, broken relationships, or invalid data.

The most common ones are:

Primary Key → uniquely identifies a record (e.g., id).

Foreign Key → connects two entities (e.g., task.user_id links to user.id).

Unique → ensures no duplicates (like email addresses).

Not Null → prevents missing values for important fields.

Think of constraints as the traffic rules of your database. Without them, everything collides.

Normalize Your Data

A lot of beginners make one big mistake — they repeat data across tables.

For instance, if your “Task” table contains the user’s name and email for every task, your database will become redundant and hard to maintain.

Normalization helps avoid that. It means:

Each piece of data should live in one place.

If two tables need it, use a relationship instead of duplication.

So instead of saving the user’s name in every task, just store the user’s ID and reference it from the User table.

That’s clean, efficient, and scalable.

Visualize Your Design

At this point, you can visualize your structure:
`User

id
name
email

Task

id
title
description
completed
user_id

Relationship: One user can have many tasks.

That’s the backbone of your database — before a single line of SQL or Django code.

This is also the stage where backend developers usually create quick ER diagrams. You can use free tools like draw.io, dbdiagram.io, or even paper and pen.

Validate Your Design

Before finalizing your design, ask yourself:

Can this structure handle future features?

Can another developer understand it easily?

Is every piece of data traceable?

A good database design should make sense without needing explanation.

Conclusion

Designing a database like a developer isn’t about memorizing SQL commands. It’s about understanding your data and its relationships before you code.

When you design this way, everything that comes after, your models, serializers, APIs, and even performance tuning, becomes clearer and easier to manage.

So next time you start a project, close your editor for a moment and open your mind.
Sketch your data. Think in entities, relationships, and rules.
That’s how you build systems that last.

How does one become a Cracked Engineer?

Mari — Fri, 31 Oct 2025 00:21:10 +0000

The word “cracked” gets thrown around a lot online. In gaming, it means you’re so good it feels unreal — like your brain moves faster than the game itself.

Now, picture that in engineering. A cracked engineer is the one who can take chaos and turn it into logic. The person who doesn’t just build things that work but things that last.

But here’s the thing:
Nobody starts cracked.
You become one, slowly, through consistency, frustration, and curiosity that borders on obsession.

Let’s talk about what that really looks like.

You Stop Coding Just to Code

A cracked engineer doesn’t write code just for completion. They design, question, and imagine the system as a living thing.

They don’t stop at “does it work?”
They ask:

“What happens if this scales?”

“Can this be simplified?”

“What breaks first if I push this harder?”

You stop being a developer and start becoming a designer of systems.

You Build From Curiosity, Not Pressure

Most people learn because they have to.
Cracked engineers learn because they want to know.

They go beyond frameworks and tutorials. They open-source code. They dig into how APIs handle requests. They ask “why” until the concept gives up.

Curiosity is your biggest unfair advantage — it compounds faster than any tech trend.

You Master the Fundamentals Until They Become Reflex

Frameworks come and go. The core stays.

A cracked engineer knows how computers actually think.
They’re comfortable with:

Algorithms and data structures

Networking and how the web works

Database design and indexing

Operating systems, memory, and concurrency

When you understand the fundamentals, you’re never lost — even in a new stack.

You Build, Break, and Rebuild

Tutorials give you structure. Projects give you reality.

Every real build teaches you how software behaves in the wild — how bugs sneak in, how edge cases ruin logic, how architecture decisions affect scaling.

The fastest way to become cracked is to build, fail, and rebuild.
Perfection doesn’t make you better — iteration does.

You Stop Worshiping Tools

Cracked engineers don’t argue over stacks. They pick the right one for the job.
They understand that frameworks are tools — not badges of honor.

They can switch from Django to FastAPI, or React to Svelte, and still perform.
Why? Because their foundation is thinking, not memorizing.

You Fall in Love With Boring Consistency

There’s nothing glamorous about repetition — but that’s where mastery hides.

They show up.
They refactor code.
They debug until their brain hurt.
They build habits that outlive motivation.

The truth is, consistency is the real talent.

You Teach, Share, and Reflect

Cracked engineers explain what they know.
Not for validation — but because teaching reveals the gaps in your understanding.

Write a dev.to post.
Share your thought process on X.
Document your projects.
It’s not about clout — it’s about clarity.

You Stay Humble, Even When You’re Good

The deeper you go, the more you realize how little you know.
Cracked engineers aren’t loud — they’re calm.
They ask questions even when they’re the smartest in the room.
They understand that arrogance ends growth.

Final Thought

Being cracked isn’t about being the smartest.
It’s about being the most curious, consistent, and self-aware.

You get there by staying in love with the process, not the title.
And one day, without noticing, you’ll look back and realize… you’ve become the kind of engineer you once looked up to.
This is a journey I'm willing to embark on, I don't care how long it takes, but one thing I know is that it will eventually click

What if the Internet had been built differently?

Mari — Mon, 27 Oct 2025 15:21:47 +0000

When Alex was a kid, he loved the sound of the dial-up tone. It meant the world was opening up again, a small blue-and-white window through which he could ask questions no one around him could answer. Years later, as a developer, he realized that the internet he grew up with was not designed for wonder anymore. It was designed for profit, precision, and attention.

Sometimes, Alex wonders, what if the internet had been built differently?

The Internet We Got
The internet we have today grew out of government research, academic curiosity, and later, the ambitions of private corporations. Its architecture, open, scalable, and permissionless, made innovation possible. Anyone could build, publish, or connect.

But openness came with trade-offs. When data became currency, privacy became collateral. What started as a network for sharing knowledge became a machine for collecting it. Every click, like, and scroll turned into behavioral data, valuable not because it taught us, but because it could predict us.

The design choices of the 1990s shaped everything that followed. Convenience triumphed over control. Algorithms replaced editors. Platforms replaced communities.

The Internet We Could Have Had
Imagine if, from the start, the internet had been built around privacy, not publicity.

Every message is encrypted.
Every user owns their data.
No hidden trackers, no personalized ads.
Such a world might have moved more slowly. Free services might not have been free. But perhaps trust in the web, and in each other, would have been stronger.

Or imagine a decentralized internet, not one ruled by a few tech giants, but powered by millions of interconnected peers. No single company owns your photos or your memories. Innovation would be local. Communities would thrive without algorithms deciding who sees what. But chaos might grow too. Decentralization, while freeing, is messy. It demands responsibility we’re not used to carrying.

There’s also the academic internet, one rooted in knowledge instead of commerce. If universities had led their expansion instead of corporations, our feeds might be filled with ideas, not ads. Learning, not outrage, could have been the metric of success.

The Cost of Convenience
We rarely notice how design decisions shape our behavior. Infinite scroll wasn’t an accident. Neither was the notification bell. Every layer of the web is optimized to keep us hooked, not because we asked for it, but because attention pays bills.

Yet, what we gained in access, we lost in depth. The early web felt like wandering through a library. Today’s web feels like surviving a carnival, loud, bright, and endless.

If the internet had been built differently, maybe we would pause more. Maybe we’d seek meaning over momentum.

The question we should all ask ourselves
The truth is, it’s not too late to rebuild parts of it. Developers are re-imagining decentralized protocols, researchers are fighting for data ethics, and communities are reclaiming spaces for genuine connection.

The question isn’t only what if the internet had been built differently, it’s what if we start building it differently now?

Alex still writes code. But every time he commits to a new project, he remembers that the next generation will live inside the web he helps create. The future internet is still being written, line by line, choice by choice.

The internet was never inevitable; it was designed.
And anything designed can be redesigned, if we dare to imagine better defaults.

LLMs & Agents Every Developer Should Know

Mari — Fri, 24 Oct 2025 09:01:02 +0000

In 2025, AI for development isn’t just autocomplete. We now have agents and domain-specialized models that write UI, reason over codebases, debug, and even propose whole features. But which ones truly elevate your workflow? Here are five tools (or models) you should have on your radar — and how to put them to work.

Kombai — The Frontend Agent

What it is
Kombai isn’t a generic LLM. It is an AI agent built specifically for frontend development. It understands UI, reads your existing codebase, indexes components, and produces production-ready frontend code (React, HTML/CSS, Tailwind, etc.).
Kombai
+2
OneClick IT Consultancy
+2

You can feed it Figma designs or UI descriptions, and it generates the code, fixes errors, and previews changes.
videosdk. live
+1

Strengths / Why use it

Deep specialization in frontend work — design to code pipeline.

It indexes your current repo so its outputs align better with your existing code.
Medium
+2
DEV Community
+2

It auto-fixes lint / TypeScript / runtime errors in generated UI.
OneClick IT Consultancy

You can choose your stack (React, UI library, router pattern) and it adapts.
Medium
+1

Where it might struggle / cautions

It’s largely frontend-focused; for backend logic or complex system reasoning, it may not be optimal.

Overhead: indexing large repos might cost time.

Generated code still needs review — even though it auto-fixes many errors, architecture decisions are subjective.

How to use it

Install as an IDE plugin (e.g., VS Code) or integrate in your frontend workflow.
Medium
+1

Allow it to index your existing components and code structure.

Give it UI goals or design assets (Figma, wireframes, etc.).

Review proposed component/pages, adjust, and deploy.

If you build lots of UI, Kombai can free you from tedious view layer writing so you focus on logic, data, and product.

GPT-5 Codex — The Generalist Coding Agent

What it is
GPT-5 Codex is a version of GPT-5 optimized for coding tasks — more agentic, more context-aware in code environments, and tuned to operate in development workflows.
Bind AI IDE
+2
Latent Space
+2

It acts like a powerful “assistant developer” that can scaffold features, refactor modules, write tests, propose pull requests, or help you debug across languages.

Strengths / Why use it

Strong multi-language support and reasoning.

Better at larger, cross-file tasks (architectural suggestions, complex refactors).

It balances creativity and constraint well. In comparison, it tends to produce more feature-rich outputs.
Latent Space
+3
Codeaholicguy
+3
Bind AI IDE
+3

Where it might struggle / cautions

May over-complicate simple tasks if prompts are vague.

Hallucinations: even powerful models can create incorrect code, so always test.

Latency or context window limits if your codebase is huge.

How to use it

Use in environments like Cursor or Codex CLI.

Pass the model the full project context or multiple files so it can reason across layers.

Prompt for incremental steps: scaffold → test → review → refine.

Use as your main “assistant dev” for feature proposals, architecture reviews, or cross-cutting changes.

In many dev workflows, GPT-5 Codex is now becoming the default “AI partner” for serious coding beyond autocomplete.

Cursor — The Model Orchestrator / IDE Bridge

What it is
Cursor is not just a model — it’s a development environment (or platform) that lets you plug in multiple LLMs (OpenAI, Claude, etc.), compare them, switch agents, and orchestrate your coding workflow.
Cursor
+1

In Cursor, you can swap between GPT-5, Claude Code, Grok, etc., and see which model works best for a given task.
Cursor
+2
Codeaholicguy
+2

Strengths / Why use it

Flexibility: Try multiple models side by side.

You don’t need to be locked into one LLM provider.

Cursor can manage context windows and routing logic (which model to use for which task).

Where it might struggle / cautions

Some tasks may require deep integration beyond what Cursor supports out of the box.

Performance and latency differ depending on the model you choose.

Maintaining context across model switches can be challenging.

How to use it

Install Cursor as your coding environment or plugin.

Connect multiple model APIs (OpenAI, Claude, Grok).

For each code task, test with two or more models, compare outputs, and pick the best.

Use Cursor’s context management to feed in relevant files or modules for better results.

If you like experimentation and want to avoid vendor lock-in, Cursor is your swiss army knife for AI-assisted dev.

Grok (Grok Code Fast / Grok Models)

What it is
Grok is a coding-oriented AI model or agent (often referenced as “Grok Code Fast”) that competes in the “developer assistant vs feature builder” space. In tests, it’s used alongside GPT-5 and Claude to see which is more efficient for code tasks.
Codeaholicguy

Its outputs are often more step-by-step, breaking tasks into smaller pieces. It may produce less polished architecture than GPT-5, but more detailed scaffolding.
Codeaholicguy
+1

Strengths / Why use it

Good at stepwise decomposition of tasks (breaking down what to do next).

Might expose details (intermediate steps) that other models hide.

Faster in certain tasks or lower-cost alternatives, depending on licensing.

Where it might struggle / cautions

Its final outputs may require extra refinement compared to GPT-5 or Claude.

For large architectural tasks, it might lack a global perspective.

May produce verbose scaffolding rather than clean, minimal code.

How to use it

Ask Grok to generate tasks step by step: “Here’s feature X, break it into subtasks, write initial code.”

Use it in a pipeline: Grok for scaffolding, then another model for refinement.

Evaluate and prune the extra steps it gives — sometimes its detailed path is more than you need.

Grok is useful when you want transparency in how the AI arrives at its answers, or when you like seeing the scaffolding explicitly.

Claude (Claude Code / Claude Sonnet etc.)

What it is
Claude is the AI family from Anthropic. Recent versions like Claude Code or “Sonnet” are used for code generation, reasoning, and agentic tasks.
Codeaholicguy
+2
Builder.io
+2

In comparison tests, Claude’s style is described as clean, concise, and safe. Some users prefer its outputs for clarity over the verbosity of GPT-5.
Codeaholicguy

Strengths / Why use it

Reliable, “reasonable” outputs with fewer wild hallucinations.

Good balance of clarity and structure.

In mixed model setups (Cursor, etc.), Claude often produces code that’s easy to review.

Where it might struggle / cautions

It may not be as “creative” or aggressive with adding new features.

Slight delay in token output compared to faster models in some contexts.
Builder.io

For deeply architectural reasoning, sometimes it errs on the side of caution — being conservative.

How to use it

Use Claude Code for everyday coding tasks: documentation, bug fixes, and small features.

Use Sonnet / recent Claude versions when you want cleaner output, and you can read faster.

In multi-model setups, use Claude as your “safe fallback” when GPT-5 or Grok noise is too much.

In many dev stacks, Claude becomes the model you trust when you want clean, reviewable code.

You’ll often mix them. For example:

Use Grok or GPT-5 to outline tasks,

Use Kombai for frontend UI code,

Use Claude to polish, refactor, document, or tone down edge cases.

Final Thoughts: Build Your AI Dev Stack, Don’t Just Pick One

These five tools don’t compete — they complement. Select the right tool for the right job. Over time, you’ll see which model shines for frontend, which for architecture, which for debugging, and which for polish.

Start by picking one to integrate into your workflow (Kombai if you're UI heavy, GPT-5 Codex or Claude Code if you build a full stack). Use it today — let it carry part of your cognitive load. Then layer others around it. The future of development isn’t just writing code; it’s orchestrating which intelligence writes which part.

Would you like me to polish this into a Medium-ready draft (with intro hooks, transitions, SEO title + tags) so you can drop it right into publish mode?

What if your startup could grow itself?

Mari — Wed, 22 Oct 2025 11:06:33 +0000

There’s a moment every creator, marketer, or founder faces — that quiet frustration of having ideas but no direction, ambition but no system, content but no traction. You spend hours thinking about what to post, how to show up, and when to engage — and somehow, it still doesn’t click.

Growth Terminal changes that.

It’s not just another AI writing assistant.
It’s a growth operating system — a platform that understands your voice, your rhythm, and your goals, and then amplifies them with intelligence.

The Future of Growth Is Personal

What makes Growth Terminal different is simple but powerful: it doesn’t try to replace you — it empowers you.

Instead of throwing out generic content ideas or robotic copy, it studies your past posts, your tone, and the type of audience you attract. Then it gives you suggestions that sound like you, think like you, and scale you.

That’s the secret most AI tools miss. Growth Terminal helps you grow authentically, not artificially.

From Chaos to Clarity

Every creator knows the chaos of maintaining consistency — the mental fatigue of trying to stay visible, creative, and strategic all at once.

Growth Terminal cuts through that noise.
It gives you a steady flow of content ideas, trend insights, and even smart replies that help you join real conversations in your niche.

No more blank screens. No more second-guessing.
Just clarity — every single day.

Consistency Without Burnout

The difference between those who grow and those who fade is consistency. But consistency is hard when it relies only on willpower.

Growth Terminal builds structure around your creativity.
You can generate, plan, and schedule your posts across X (Twitter) and LinkedIn — all in one place.

Imagine having your ideas, strategy, and publishing system unified in a single dashboard.
That’s not just productivity — that’s peace of mind.

AI That Feels Human

There’s a misconception that AI kills authenticity. Growth Terminal proves the opposite.
Its intelligence doesn’t erase your human touch — it enhances it.

Each post idea feels handcrafted to your niche and your style.
Each reply suggestion feels natural, not forced.
Each automation feels like your brand speaking with precision and purpose.

It’s the kind of AI that doesn’t just save time — it helps you think better, create faster, and grow smarter.

The Smartest Tool for Modern Creators

Whether you’re a:

Solo creator building your voice online,

The founder is trying to share insights, or

Marketing team looking to amplify reach —

Growth Terminal gives you everything you need to stay consistent, visible, and impactful.

It helps you:

Discover content ideas that resonate.

Write with your authentic voice.

Schedule and automate without losing control.

Stay ahead of trends that actually matter to your audience.

It’s more than a productivity boost. It’s a mindset shift — from reacting to leading.

Why Growth Terminal Works

Because it’s designed for how growth actually happens — not through luck or hacks, but through alignment.
Alignment between your ideas, your voice, and your visibility.

Every feature of Growth Terminal — from smart content generation to reply assistance — is built around one principle: help you grow without burning out.

It’s the perfect blend of automation and authenticity.

A Tool Built for the New Internet

We’re entering an era where attention is currency, and trust is everything.
Growth Terminal helps you earn both — not by gaming algorithms, but by showing up consistently with clarity and confidence.

When your content reflects who you are and your growth becomes predictable, that’s when real traction begins.
And that’s exactly what Growth Terminal helps you build.

Here is a little demo of how to use Growth Terminal:

https://vimeo.com/1129481568?share=copy&fl=sv&fe=ci

The best way to confirm information is to check it out:
https://growthterminal.ai/?via=mari

Final Thoughts

Growth Terminal isn’t just another AI platform. It’s a new way of thinking about online growth.

It turns the exhausting cycle of idea-hunting, drafting, and scheduling into a simple, structured system — one that grows with you.

If you’ve ever felt like you’re creating without direction or posting without results, Growth Terminal is your missing link.
It’s the silent partner that helps your ideas reach the people who need them — faster, smarter, and more authentically than ever before.