DEV Community: Vincent Jande

How AI Can Make You a 10x Software Engineer

Vincent Jande — Thu, 14 Aug 2025 20:46:35 +0000

In the rapidly evolving world of technology, artificial intelligence (AI) has sparked intense debates. Some predict that AI will replace software engineers entirely, while others argue that building products has become so straightforward that traditional software engineering skills are obsolete. I strongly disagree with both views. In fact, learning software engineering is more valuable than ever. With a solid foundation, you can leverage AI to handle edge cases, make informed decisions, and automate boilerplate code. This turns you into a productivity powerhouse. In this article, I'll share how I used AI to build a complex product in just three weeks (part-time), what I learned from the experience, and why skilled engineers are uniquely positioned to thrive in this AI-driven era.

The Power of Experience in an AI World

Before diving into the specifics, consider this: I'm currently working on another project where I reached a minimum viable product (MVP) in just a couple of days. Why so fast? My years of software engineering experience allowed me to architect the solution efficiently, anticipate pitfalls, and integrate AI tools seamlessly. Without that knowledge, AI alone wouldn't have sufficed. It's the synergy between human expertise and AI that creates magic.

This brings me to the main story: I was tasked with building a trading academy API. This wasn't a simple app; it needed a full learning management system (LMS) for courses, channels for trading signals, direct messaging (DMs) for user interactions, and subscription management. A project of this scope would typically take several months for a solo developer. But by combining my engineering skills with AI assistance, I completed it in three weeks. And it was not even full-time. If I'd dedicated myself entirely, it could have been done in two. Here's how I did it.

Laying the Foundation: Structure and Tech Choices

Success started with thoughtful planning, drawing on my software engineering background. I knew the pros and cons of common architectures; for instance, the Model-View-Controller (MVC) pattern can lead to cluttered code in larger projects. Instead, I opted for a feature-based structure to keep things modular and scalable.

I chose Node.js with Express.js for the backend to enable rapid development, paired with MongoDB for flexible data storage. Crucially, I designed the features to be loosely coupled, allowing me to build and test one at a time without ripple effects. This modularity is a hallmark of good engineering and made AI integration smoother.

For each feature, I enforced a consistent structure: controllers for handling requests, services for business logic, validators for input checks, routes for API endpoints, models for data schemas, types for TypeScript definitions, and middlewares for cross-cutting concerns. I also created a shared utilities folder for reusable components.

Building Features with AI: From Auth to Messaging

I kicked off with authentication, a standard but critical component. Using Claude (an AI coding assistant), I generated boilerplate code for email-based auth with refresh tokens. The output was well-structured, but it had a few errors, like outdated dependencies, which I quickly fixed using my knowledge. After testing in Postman, it was solid.

Next came user management. I separated the User model (focused on authentication) from the Profile model (for easily updatable user details). Again, Claude provided the CRUD (Create, Read, Update, Delete) boilerplate. I didn't accept it blindly; I reviewed for adherence to my structure, fixed issues, and ensured everything worked through rigorous testing.

File management followed suit. Claude generated the code, but I spotted an outdated AWS SDK version in the output. This was a reminder that AI tools might not always reflect the latest updates. Drawing on my experience, I upgraded it, set up an AWS S3 bucket with a CDN for efficient delivery, and verified functionality.

Courses were straightforward: same process, with minor error fixes leading to a working LMS module.

Messaging proved trickier. Midway through, I hit Claude's chat limit. Undeterred, I had the AI generate a detailed prompt summarizing the project's state, structure, and progress. I pasted this into a new chat session, allowing the AI to pick up seamlessly. The structure shifted slightly at first, but I guided it back on track. In the end, I handled most error resolutions myself, making necessary updates to ensure robust DMs and channels.

Lessons Learned: AI as a Bootstrapper, Not a Replacement

This project reinforced a key insight: AI excels at bootstrapping. It generates standard solutions quickly, handles repetitive tasks, and accelerates development. But it's not infallible. Errors, outdated info, and context loss require human intervention. That's where software engineering shines: knowing what to ask, spotting flaws, and refining outputs.

AI has empowered engineers to become solo founders, pushing products to market at unprecedented speeds. It hasn't made us obsolete; it's elevated us to "god-like" productivity levels. Imagine completing months of work in weeks. That's the reality for those who know how to wield it. A novice "vibe coder" couldn't achieve this; only a skilled engineer can direct AI effectively, avoiding pitfalls and ensuring quality. In my case, AI shaved off boilerplate drudgery, letting me focus on architecture and innovation. The result? A fully functional trading academy API, delivered efficiently.

Conclusion: Embrace AI, But Build Your Foundation First

AI isn't here to replace software engineers. It's here to amplify them. By mastering the fundamentals, you can become a 10x engineer: faster, more innovative, and capable of solo feats that once required teams. My experience proves it: leverage AI for speed, but rely on your expertise for precision.For inquiries, reach out via X at @janvinsha.

Ethereum vs Solana: Understanding Data Storage Differences in Their Ecosystems

Vincent Jande — Wed, 08 Jan 2025 19:04:30 +0000

Introduction
In the rapidly evolving blockchain landscape, Ethereum and Solana stand out as two of the most prominent platforms, each with its unique architecture and capabilities. While both aim to facilitate decentralized applications (dApps) and smart contracts, their approaches to data storage differ significantly. Understanding these differences is crucial for developers choosing the right platform for their projects.

Ethereum's Smart Contract Data Storage
Ethereum, the pioneer of smart contracts, allows developers to store data directly within smart contracts. This capability is intrinsic to Ethereum’s design, where each smart contract is essentially a stateful entity on the blockchain. Developers can define and manage variables within contracts, enabling complex logic and data manipulation directly on-chain.

Storing data within smart contracts offers several advantages:

Simplicity and Cohesion: All related logic and data reside within the same contract, making the development process more straightforward.
Atomic Transactions: Operations on data can be executed atomically, ensuring consistency and reliability.
Rich Ecosystem: Ethereum’s mature tooling and extensive documentation support seamless data management within contracts. However, this approach also has drawbacks. Storing large amounts of data on-chain can be expensive due to gas fees, and it may lead to scalability issues as the blockchain grows.

Solana’s Account-Based Data Separation
In contrast, Solana adopts a different strategy by separating data storage from program logic. Instead of embedding data within smart contracts, Solana uses separate accounts to hold data. These accounts are often Program Derived Addresses (PDAs), which are deterministic and derived from the program’s public key and specific seeds.

Key aspects of Solana’s data storage model include:

Modularity: By decoupling data from program logic, Solana promotes a more modular architecture. Programs can interact with multiple data accounts, enhancing flexibility.
Scalability: This separation allows for more efficient data handling and reduces the overhead on individual programs, contributing to Solana’s high throughput.
Security: PDAs ensure that only the designated program can modify the associated data, enhancing security through deterministic address generation. While Solana’s approach offers scalability and modularity, it introduces complexity. Developers must manage multiple accounts and ensure proper interactions between programs and data accounts. This can increase the learning curve compared to Ethereum’s more integrated model.

Comparative Insights

Performance and Scalability: Solana’s account-based model and high throughput make it suitable for applications requiring rapid transactions and extensive data manipulation. Ethereum, while slower and less scalable, benefits from its established network and robust security features.
Developer Experience: Ethereum’s all-in-one contract data storage is more intuitive for developers familiar with traditional smart contract development. Solana’s separation of data and logic requires a deeper understanding of account management and PDA utilization.
Use Cases: Ethereum excels in scenarios where tight integration of logic and data is beneficial, such as decentralized finance (DeFi) protocols and complex dApps. Solana shines in high-frequency applications like gaming, real-time analytics, and NFT platforms that demand speed and scalability.

Conclusion
Both Ethereum and Solana offer powerful ecosystems for building decentralized applications, but their approaches to data storage reflect different priorities and architectural philosophies. Ethereum’s ability to store data within smart contracts provides simplicity and cohesion, making it ideal for a wide range of applications. On the other hand, Solana’s separation of data into PDAs and other accounts enhances scalability and performance, catering to high-throughput demands.
For developers, the choice between Ethereum and Solana hinges on the specific requirements of their projects. Understanding these key differences in data storage is essential for leveraging each platform’s strengths and building efficient, scalable, and secure decentralized applications

A Lesson in Simplicity: Sorting Files Like a Pro in an Interview

Vincent Jande — Tue, 29 Oct 2024 14:30:39 +0000

During a technical interview for a full-stack developer role, I found myself in a familiar yet unexpectedly challenging situation. Everything had been going smoothly until the interviewer presented me with a task that seemed simple at first.

“Can you sort these filenames the way they’d appear in a file explorer, in ascending order?” they asked.

I thought, “Piece of cake.” Sorting is such a fundamental operation that I didn't expect any trouble. But as soon as I started writing the code, I hit a snag. The filenames were all over the place some were simple, but others included numbers, letters, and combinations of both.

I tried using a basic string sorting method like:
array.sort();
But this produced an odd result. The numbers were sorted lexicographically (meaning “10” would come before “2” because it starts with a “1”), and mixed alphanumeric strings weren’t in the correct order. It was a mess, and it didn’t resemble the natural order you see in file explorers at all.

I could feel the clock ticking and pressure building up. I tried to work through various custom comparison functions to handle the numbers properly, but nothing seemed to click.

Then, I remembered a simple trick I had read about not too long ago: localeCompare.

localeCompare allows you to compare strings in a way that mimics how humans sort things. By using it with the numeric option, it handles the numbers as actual numbers rather than comparing them as text. Here’s the code I used:
array.sort((a, b) => a.localeCompare(b, undefined, { numeric: true, sensitivity: 'base' }));
This single line of code sorted the filenames exactly like a file explorer would: numbers were ordered naturally, and letter/number combinations were handled seamlessly.

As soon as I ran the code, I saw the correct order appear on the screen. The filenames were perfectly sorted in ascending order, just like in a file explorer. I smiled as I explained the solution to the interviewer, who seemed pleased with how I resolved the issue.

What initially felt like a complicated problem ended up being solved with a simple, elegant solution. It was a reminder that sometimes the most effective tools are the simplest, and knowing those small tricks can make all the difference.

Debugging WebSocket Connection Failure: wss://relay.walletconnect.org

Vincent Jande — Thu, 24 Oct 2024 15:01:34 +0000

If you've encountered a WebSocket connection failure when trying to use WalletConnect with an error like:
WebSocket connection to 'wss://relay.walletconnect.org' failed
this error might be linked to access restrictions applied by certain services to specific countries, including Nigeria.

Understanding WebSocket and WalletConnect

WalletConnect is an open protocol for connecting decentralized applications (dApps) to mobile wallets through QR code scanning or deep linking. It relies on WebSocket (WS) connections to relay encrypted communication between the dApp and the wallet. The WebSocket protocol, denoted by the wss:// scheme (secure WebSocket), is crucial for maintaining a persistent connection between the client and server for real-time interactions.
However, you might encounter the WebSocket failure for the relay.walletconnect.org endpoint due to geo-blocking. Some platforms, including WalletConnect's relayer, restrict access to certain countries like Nigeria, potentially due to regulatory compliance or risk management strategies.

Common Symptoms

Connection Timeout or Failure: When initiating the connection to wss://relay.walletconnect.org, the WebSocket handshake fails.
Inconsistent Behavior: The issue may persist across different networks and devices in Nigeria but may work without problems when using a VPN or accessing the service from a different location.
Country-Specific Restrictions: WalletConnect's relay servers could be enforcing geo-blocks, resulting in connection denials for users based in regions with restricted access.

Workarounds

If you're facing this error, there are a few options to explore:
Use a VPN: A simple but effective solution is using a VPN to connect from a country where WebSocket connections to WalletConnect relayers are not blocked.
Proxy Services: Set up a proxy server in an unrestricted region to relay the WebSocket connection on your behalf.

In conclusion, this issue highlights the importance of understanding country-specific restrictions when developing or using Web3 tools. While frustrating, using a VPN or alternative relayer services can help you work around the problem.