DEV Community: Aditya Madhok

From Python Projects to Real-World Solutions: My Developer Journey on Topmate

Aditya Madhok — Sat, 10 Oct 2026 13:15:23 +0000

How I'm turning my coding skills, creative ideas, and curiosity into practical digital solutions.

As developers, we often start by learning a programming language, experimenting with small projects, and trying to understand how technology works behind the scenes. But eventually, a question comes to mind: How can I use what I know to solve real problems for other people?

That's a question I've been exploring throughout my development journey, and it's one of the reasons I've created my profile on Topmate.

You can find me here: topmate.io/adityamadhok.

Who Am I?

I'm Aditya Madhok, a developer interested in Python programming, application development, web technologies, and building useful digital products.

Python is one of the main tools I enjoy working with. I like exploring how a simple idea can turn into a working application, whether it's a desktop utility, an interactive graphical user interface, or a web-based project.

I'm also continuously expanding my knowledge of web development and databases, including SQLite. For me, learning doesn't stop after understanding a concept. I want to experiment with it, apply it in projects, and discover what I can build with it.

I also enjoy exploring creative ideas at the intersection of technology and astrology. Building astrology-related web applications has given me opportunities to think beyond conventional programming exercises and explore how software can present specialized information in an engaging way.

Why I Created My Topmate Profile

Having technical skills is one thing. Making those skills accessible to people who need them is another.

I created my Topmate profile to establish a place where people can connect with me, explore opportunities to work together, and discuss their technical ideas.

My goal is straightforward: to make it easier for people to approach me with programming questions, application ideas, or projects they want to bring to life.

Sometimes, someone has an idea for a small application but doesn't know where to begin. Other times, a repetitive task could be automated, or an existing workflow could be made more convenient with a custom tool.

These are the kinds of possibilities that make software development interesting to me.

What Kind of Projects Interest Me?

1. Python Programming and Automation

Python is useful for much more than writing scripts or solving coding exercises. It can help automate repetitive tasks, process information, build utilities, and create applications tailored to specific needs.

I'm interested in developing practical Python solutions that focus on usability and clear functionality.

2. GUI-Based Desktop Applications

Not every application needs to run in a browser.

A desktop application with a graphical user interface can be a great solution when someone needs a straightforward tool for a particular workflow.

I enjoy exploring how Python can be used to create applications with interfaces that make software easier to interact with, even for people who aren't particularly technical.

3. Web Development

Web applications offer another exciting way to turn ideas into accessible products.

I'm continuing to develop my understanding of web technologies and databases, with an interest in building interactive applications that combine functionality with a good user experience.

I'm especially interested in projects where the frontend, application logic, and data storage work together to solve a specific problem.

4. Creative and Astrology-Based Applications

One area I particularly enjoy exploring is the combination of programming and astrology-related concepts.

These projects challenge me to think about how information can be organized, processed, and presented through an interactive application.

They also remind me that software development isn't limited to traditional business tools. Technology can be applied to niche interests, creative experiments, and highly specific use cases.

My Approach to Building Software

I believe a useful application begins with understanding the problem.

Before jumping into code, it's important to consider what the user actually needs, which features matter most, and how the final product should work.

My general approach is to:

Understand the idea: Identify the problem the application is intended to solve.
Plan the functionality: Break the idea into smaller, manageable components.
Choose suitable technologies: Select tools that fit the project's requirements rather than adding unnecessary complexity.
Build and test: Develop the application incrementally and check that its core functionality works as expected.
Improve through feedback: Identify opportunities to make the application more useful and easier to use.

This approach also influences how I learn new technologies. Instead of treating learning and building as completely separate activities, I try to connect new concepts with practical projects.

Why I'm Sharing My Work on DEV Community

DEV Community is a place where developers can share their experiences, explain what they're building, and learn from one another.

I want to use this space to document my development journey, discuss technical concepts, share project ideas, and reflect on the lessons I learn while building applications.

I also believe that sharing your work helps you think more clearly about it. Explaining a project to someone else can reveal gaps in your understanding and encourage you to improve your implementation.

Whether you're an experienced developer, a student, or someone experimenting with your first application, there's always something new to discover.

Let's Connect and Build Something

I'm interested in connecting with people who have ideas for software projects, need help exploring a technical problem, or want to discuss application development.

If you're considering a Python utility, a GUI-based application, a web development project, or an idea that combines technology with a specialized interest, feel free to visit my profile.

Explore my Topmate profile: https://topmate.io/adityamadhok

I'm looking forward to continuing my journey as a developer, learning new technologies, building useful projects, and connecting with people who enjoy turning ideas into working software.

Because, ultimately, programming isn't just about writing code. It's about understanding problems, experimenting with solutions, and creating something that can make a difference to the person using it.

What are you building right now? I'd love to hear about your projects, the technologies you're exploring, and the problems you're trying to solve. Let's connect in the comments!

I Built Career Command Center: An AI-Powered Job Search Dashboard with Python & Textual.

Aditya Madhok — Sat, 13 Jun 2026 11:32:36 +0000

If you've ever managed dozens of job applications across multiple websites, you know how chaotic the process becomes.

Spreadsheets, bookmarked job listings, resumes tailored for different roles, interview notes, cover letters, and application tracking quickly become overwhelming.

So I decided to build something for myself.

Introducing Career Command Center — an AI-powered terminal dashboard built with Python and Textual that helps job seekers organize and accelerate their job search.

Why I Built It

I wanted a single application where I could:

Track applications
Search jobs
Generate cover letters
Match resumes against jobs
Prepare for interviews
Analyze job descriptions with AI
View application statistics

without constantly switching between websites and tools.

The result is a desktop application that feels like a futuristic command center for career management.

Tech Stack

Frontend

Python
Textual (Terminal UI Framework)
Rich

Backend

SQLite
Groq AI API

Job Sources

RemoteOK
Browser-integrated Cutshort search
Extensible multi-source architecture

Packaging

PyInstaller
Windows Executable
Linux Binary

Features

Application Tracking

Keep track of:

Applied jobs
Interviews
Offers
Rejections

with a built-in SQLite database.

AI Job Analyzer

Paste any job description and receive:

Skills required
Experience level
Responsibilities
Suggested interview topics
Resume improvement recommendations

Resume Match

Upload your resume and compare it against a job description.

Get:

Match score
Missing skills
Resume gaps
Suggested improvements
ATS-style feedback

AI Cover Letter Generator

Generate customized cover letters in seconds.

No more rewriting the same template over and over.

Interview Preparation

Generate:

Technical questions
Behavioral questions
Follow-up questions
Preparation tips

based on a target role.

Real Job Search

Search remote opportunities directly from the application.

Current integrations include:

RemoteOK

API Settings

Users can connect their own Groq API key.

The application stores the key locally so users remain in control of their usage.

Dashboard Overview

The dashboard provides:

Total Applications
Interviews
Offers
Rejections

along with quick navigation to all tools.

Packaging Challenges

One interesting challenge was packaging a Textual application into standalone executables.

Textual applications are terminal-based, so Windows builds require a console-enabled executable rather than a GUI-only executable.

After several iterations with PyInstaller, I successfully packaged:

Windows EXE
Linux Binary

for distribution.

Screenshots

Dashboard

AI Job Analyzer

Resume Match

Interview Preparation

Job Search

API Settings

What I Learned

Building this project taught me a lot about:

Textual application development
SQLite integration
AI-powered workflows
Desktop packaging
Cross-platform deployment
Product design for job seekers

Future Roadmap

Planned improvements include:

Resume optimization
ATS scoring
PDF report exports
Multi-source job aggregation
Advanced analytics dashboard

Availability

Career Command Center is available as a downloadable desktop application.

If you'd like to support the project and get access to future updates, you can purchase it here:

Windows and Linux versions available:

👉 https://adityamadhok.gumroad.com/l/Career-Command-Center

Final Thoughts

This project started as a personal productivity tool and evolved into a complete AI-powered career toolkit.

If you're learning Python, exploring Textual, or interested in building AI-powered desktop applications, I highly recommend experimenting with tools like these.

Thanks for reading.

If you'd like to see future updates, feel free to follow me here on Dev.to and share your feedback.

Happy coding and good luck with your job search!

🦋 I Built a Living Terminal Animation with Hermes Agent — Here's How It Went.

Aditya Madhok — Tue, 26 May 2026 17:54:48 +0000

Hey DEV community! I'm Aditya Madhok, and this is my submission for the Hermes Agent Challenge — a $1,000 prize pool challenge to build something cool using the open-source Hermes Agent. I ended up building something I genuinely didn't expect to pull off: a fully animated, living Butterfly Garden that runs right inside your terminal.

No GUI. No browser. Just pure Python + ANSI escape codes + a surprisingly capable AI agent.

🌸 What Is Butterfly Garden?

It's a terminal animation — a little scene that plays out in your 80x24 character grid. Here's what's happening on screen at any given moment:

🦋 A butterfly with a full state machine (Seeking → Landing → Sipping Nectar → Taking Off), flapping its wings in animated sprite cycles
🌺 Three flowers (a tulip, a daisy, and a rosebud) that sway gently with a sine-wave wind effect
✨ Floating pollen/sparkle particles drifting across the scene
🌿 Two layers of animated grass at the bottom, tilting left and right with the breeze
📜 A live narrative caption that changes based on what the butterfly is doing

The whole thing runs at ~12fps using a double-buffered render loop — meaning every frame, a fresh character and color buffer is computed, then flushed to the terminal in one write. No flicker. No tearing.

python butterfly_garden.py

That's all it takes. Press Ctrl+C to exit gracefully (cursor is restored, colors reset).

🤖 Where Does Hermes Agent Come In?

Here's the honest truth about how this got built.

I had the idea — a terminal animation with a butterfly visiting flowers. I knew the broad shape of it. What I didn't have was hours to manually tune physics, sprite timing, state machine transitions, and sine-wave grass. That's where Hermes Agent came in.

Hermes Agent is an open-source agentic system built for planning, tool use, and multi-step reasoning. It runs on your own infrastructure. I described what I wanted and let it help me reason through the architecture piece by piece:

Me: "I want a butterfly that realistically seeks out flowers, lands on them, sips nectar, then flies to the next one."

Hermes: Suggested a 4-state machine — SEEKING, LANDING, RESTING, TAKEOFF — with spring-based physics for smooth movement and a flutter noise layer for organic-looking flight.

That's the kind of architectural help that turns a vague idea into structured code fast. Hermes wasn't just autocompleting lines — it was helping me think about the problem.

🧠 The Interesting Technical Bits

Double-Buffered Terminal Rendering

def create_double_buffer():
    char_buf = [[" " for _ in range(WIDTH)] for _ in range(HEIGHT)]
    color_buf = [[RESET_COLOR for _ in range(WIDTH)] for _ in range(HEIGHT)]
    return char_buf, color_buf

Every frame builds two full 80×24 grids — one for characters, one for ANSI color codes. This gets flushed in a single sys.stdout.write() call, which prevents the partial-frame flickering you'd get from printing line by line.

Spring Physics + Flutter Noise

The butterfly doesn't just teleport to targets. It uses velocity + spring acceleration:

ax = (target_x - bx) * 0.06
ay = (target_y - by) * 0.06

flutter_x = math.sin(frame * 0.8) * 0.6
flutter_y = math.cos(frame * 1.1) * 0.4

vx = vx * 0.8 + ax + flutter_x * 0.1
vy = vy * 0.8 + ay + flutter_y * 0.1

The damping (* 0.8) prevents oscillation. The flutter noise (different frequencies on X and Y) creates that natural drifting quality real butterflies have.

Swaying Flowers via Sine Waves

def update(self, frame):
    self.sway_x = math.sin(frame * 0.04 + self.base_x) * 2.5

Each flower has a phase offset (+ self.base_x) so they don't all sway in sync — that one line makes the scene feel alive instead of mechanical.

The Butterfly Locks to the Flower While Sipping

When the butterfly is in RESTING state, it doesn't use physics at all:

elif b_state == 2:
    bx = flower_top_x  # flower_top_x updates every frame as flower sways
    by = flower_top_y

This means the butterfly visually rides the swaying flower — a tiny detail that sells the whole illusion.

🎨 What It Looks Like

────────────────────────────────────────────────────────────────────────────────
         BUTTERFLY GARDEN

     ✧  ·  ✧       o   o          ✧
                  / \_/ \
           \_/  (_ _O_)   (@)
            v   \_/ \_/   \|/
        |        |  |      |
      y |      y |  | p    | p
        |        |  |      |
 \/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/\/
         Sipping sweet nectar from a swaying blossom...
wvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwvwv

(ANSI colors render in the terminal — the butterfly shifts between orange and magenta, flowers bloom in cyan, red, and purple, grass glows green)

💡 What I Learned from Using Hermes Agent

It's excellent for architecture decisions. Asking "how should I structure the state machine?" got me a clean answer with tradeoffs explained. That's different from autocomplete.
It accelerates the boring math parts. Sine wave phase offsets, spring damping coefficients, sprite index oscillation from sin() — Hermes helped me get these right without trial-and-error guessing.
You still write the code. Hermes is an agent, not a vending machine. The final implementation is mine — but it's shaped by reasoning I did with it, not alone.
Running on your own infra matters. For a creative/personal project like this, I didn't want my prompts going anywhere proprietary. Hermes running locally gave me that freedom.

🚀 Try It Yourself

The script is self-contained — no dependencies beyond Python 3 and a terminal that supports ANSI codes (Linux/macOS out of the box, Windows Terminal works too).

# Clone or download butterfly_garden.py, then:
python butterfly_garden.py

# Exit with Ctrl+C — the terminal resets cleanly

The code is around 300 lines and heavily commented. If you want to mod it:

Add more flowers by appending to the flowers list
Change WIDTH/HEIGHT to fit your terminal
Swap BUTTERFLY_SPRITES for your own ASCII art frames
Tune flap_speed per state for different animation feels

Final Thoughts

I didn't expect a terminal animation to be this satisfying to build. There's something meditative about characters, math, and color codes combining into something that feels alive. Hermes Agent made the architectural reasoning faster and more fun — it's a tool that respects your intelligence while expanding what you can accomplish alone.

If you have questions, want to share your own Hermes Agent builds, or just want to talk terminal art — drop a comment below. I read every one. 👇

Built for the DEV Hermes Agent Challenge · May 2026 · by Aditya Madhok

Astro Career Mapper

Aditya Madhok — Fri, 30 Jan 2026 17:22:22 +0000

Choosing the right career path can be one of the most impactful decisions of a person’s life — but it’s also one of the most challenging. That’s why I created Astro-Career-Mapping, a free and open-source tool designed to help people reflect on their professional potential through a unique combination of astrology and esoteric knowledge. Hosted on GitHub under the MIT License, this project is built with accessibility and personal growth in mind.

At its heart, Astro-Career-Mapping provides users with a way to explore career direction using astrological insights. Rather than relying solely on generic personality tests or standardized career quizzes, this tool contextualizes your professional strengths and tendencies against the backdrop of your birth chart — allowing a deeper conversation with your own potential. This kind of self-reflection can be especially valuable for students, job seekers, or anyone thinking about a career pivot.

One of the major strengths of this project is that it’s free software. Because it’s licensed under MIT, anyone can use, modify, or build upon it — whether you’re a hobbyist developer, an aspiring astrologer, or a data-driven career coach. You can explore the code directly on GitHub, and even preview the live interface hosted via GitHub Pages. This openness encourages collaboration and improvement from the community, making career mapping a participatory experience.

In a landscape where many career-guidance platforms charge for assessments or limit access to premium features, Astro-Career-Mapping stands out as a free and transparent alternative. By combining ancient wisdom with modern web technologies, the tool invites users to think beyond traditional career frameworks and consider how deeper personality patterns may inform their professional lives. This can complement other career planning resources, whether they use conventional aptitude tests, AI-based analysis, or questionnaires.

I built Astro-Career-Mapping not just as a software project, but as a resource that sparks curiosity and self-discovery. Whether you’re looking for inspiration, clarity, or a new way to reflect on your goals, this tool offers a gentle, exploratory approach to career planning — and best of all, it’s available to anyone with an internet connection. Head over to the project repository to try it out, contribute, or adapt it for your own needs!

Here is the Link for this Project.