DEV Community: Umitomo

A Curious Journey Into Reverse Engineering an AI-Generated Python .exe

Umitomo — Tue, 26 May 2026 05:02:08 +0000

Introduction

I usually post weekly learning and development updates on Dev.to📝

This time, however, I decided to write a standalone article about something a little different — my first attempt at reverse engineering🦾

What started as simple curiosity quickly turned into an exciting journey of uncovering how a modern AI-generated Python application was actually structured internally🔎

TL;DR

Reverse engineered a PyInstaller-based Python .exe
Reconstructed a surprisingly large portion of the application's architecture from the packaged .exe
Analyzed .pyc files using tools like strings, pycdc, and pycdas
Learned how React/Vite frontend assets can be bundled into a standalone executable
Realized how difficult production frontend bundles are to understand without the original source code
Thought deeply about maintainability in the age of AI-generated applications

What I Reverse Engineered

As someone who works in IT administration and internal tooling, I often become curious about how applications are actually built under the hood.

This time, a coworker showed me a PDF-processing desktop application that had been created with the help of generative AI.

The overall architecture had already been explained to me verbally beforehand.
However, that led me to a simple but exciting question:

How much of an application's internal structure can actually be reconstructed just by reverse engineering the final .exe file?

That curiosity became the starting point of this exploration.

The application itself was a harmless internal utility designed for local use, and this investigation was performed purely within an authorized and educational context.

Rather than trying to analyze malware or bypass protections, I wanted to understand:

What information remains inside packaged executables
How modern Python applications are bundled
Whether frontend/backend structures could still be inferred after packaging
How much architectural detail could realistically be reconstructed from compiled artifacts alone

What made the process especially exciting was slowly piecing together the architecture from small clues hidden inside the executable.

Reverse Engineering Environment Setup

Since I was using Kali Linux on WSL for this experiment, I first prepared a small reverse engineering workspace.

Creating a Python Virtual Environment

mkdir -p ~/reverse
cd ~/reverse

python3 -m venv venv
source venv/bin/activate

At first, the virtual environment failed because python3-venv was missing:

sudo apt install python3.13-venv

After that, I recreated the environment successfully.

Installing Basic Analysis Tools

I installed a few basic tools for inspecting the executable and analyzing Python bytecode.

pip install pyinstaller

I also installed binutils so I could use strings:

sudo apt install binutils

Building `pycdc`

To inspect .pyc files more deeply, I built pycdc from source:

sudo apt install -y cmake g++ git

mkdir -p ~/reverse/tools
cd ~/reverse/tools

git clone https://github.com/zrax/pycdc.git

cd pycdc
mkdir build
cd build

cmake ..
make -j4

This generated:

pycdc
pycdas

which I later used to inspect Python bytecode files.

Extracting the PyInstaller Executable

After confirming the executable was likely packaged with PyInstaller, I used pyinstxtractor to extract its contents:

git clone https://github.com/extremecoders-re/pyinstxtractor.git

Then:

cd ~/reverse/pdf_exe

python ~/reverse/pyinstxtractor/pyinstxtractor.py PDF.exe

This generated a directory like:

PDF.exe_extracted/

Inside the extracted directory, I was finally able to inspect files such as:

app.pyc
pdf_stamp_processor.pyc
pdf-stamp-frontend/dist

This was the point where the application's overall structure started becoming much clearer.

How I Reverse Engineered It

Step 1 — Running `strings`

I first started with:

strings PDF.exe

Very quickly, I noticed Python-related strings:

python313.dll
pyi-python-flag
...

This strongly suggested that the application had been packaged using PyInstaller.

Step 2 — Inspecting the PyInstaller Archive

Next, I used:

pyi-archive_viewer PDF.exe

This helped confirm that the executable had been packaged using PyInstaller and allowed me to inspect the internal archive structure.

Step 3 — Analyzing `.pyc` Files

I then used:

pycdc
pycdas

to inspect the extracted Python bytecode files.

However, when running pycdc, I noticed that some parts of the bytecode could not be fully reconstructed.

In many cases, the output stopped after displaying messages like:

Unsupported opcode: CALL_KW (247)
from fastapi import FastAPI, File, UploadFile, Form, HTTPException
...
# WARNING: Decompyle incomplete

Instead of fully recovering the original source code, I had to combine multiple fragmented clues together:

Partial pycdc output
pycdas disassembly output
Extracted strings
Module names
API route names
Library imports

I also used generative AI to help interpret and organize those fragmented technical details while reconstructing the application's architecture.

Even with incomplete reconstruction, I was still able to identify:

FastAPI routes
PDF processing logic
OpenCV-based blank-space detection
PyMuPDF page rendering
Automatic browser launching
Local API endpoints such as:

/api/scan
/api/stamp_and_merge
/api/shutdown

Step 4 — Investigating the Frontend

The frontend bundle was much harder to understand.

The built JavaScript looked like this:

var e=Object.create,t=Object.defineProperty,...

At first, it felt almost impossible to read.

The extracted JavaScript was difficult to understand, and I could not initially tell what kind of frontend structure had originally existed before packaging.

By combining:

The extracted dist/ directory structure
The bundled JavaScript files
API communication behavior observed in the browser developer tools
And explanations generated through conversations with AI

I gradually started to understand how the frontend had likely been packaged and bundled, and that the application was probably using a modern frontend workflow similar to React/Vite.

At the same time, I also realized that the original frontend source structure itself was no longer included inside the executable.

Reconstructing the Architecture

By combining clues from strings, embedded .pyc files, frontend assets, and API routes, I was eventually able to reconstruct a rough picture of the application's architecture:

PDF.exe
    ↓
Launch FastAPI server
    ↓
Open browser automatically
    ↓
Serve React frontend
    ↓
React sends API requests
    ↓
Python processes PDFs locally

The application was not rendering a desktop GUI directly.

Instead:

FastAPI served static frontend files
React rendered the UI inside the browser
Python handled backend processing

What fascinated me most was not simply discovering the architecture itself, but realizing how much of it could still be reconstructed purely from packaged artifacts.

What I Learned

Reverse Engineering Can Reveal More Than I Expected

Before starting this experiment, I assumed that most of an application's architecture would disappear once everything had been packaged into a standalone .exe.

However, I was surprised by how many clues still remained inside the executable:

Python runtime artifacts
PyInstaller structures
Embedded .pyc files
Frontend build outputs
API routes
Localhost references
Technology-specific strings

By connecting those small clues together step by step, I was able to reconstruct a surprisingly large portion of the application's overall architecture.

That process itself was one of the most exciting parts of the experience.

“Working Software” and “Understandable Software” Are Different Things

This experience also made me think deeply about AI-generated applications and software maintainability.

Generative AI can absolutely help create working applications quickly.
However, once only compiled artifacts remain, reconstructing the original design and development intent becomes much harder.

Even after reverse engineering the executable, I still could not fully reconstruct the original frontend source code or understand every implementation detail.

That limitation itself became an important lesson for me.

It reminded me that understanding software architecture and preserving maintainable source structures are just as important as making software work.

Especially in the age of AI-assisted development.

Final Thoughts

This reverse engineering journey was honestly a lot of fun.

What made the experience especially enjoyable was gradually reconstructing the application's architecture from small technical clues hidden inside the executable.

At the same time, the experience gave me a deeper appreciation for software architecture, maintainability, and the importance of preserving understandable source code alongside AI-generated applications.

Weekly Dev Log 2026-W06

Umitomo — Thu, 21 May 2026 01:25:54 +0000

🗓️ This Week

Made a little more progress in the SwiftUI tutorial🦾
Started the journey of building my future portfolio site✈️ First, I created the project files and set up a repository on GitHub. I also started reserching React Router v7 by reading its documentation. I'm moving forward little by little🔥
Completed the ContAInment room from the AI Security Learning Path on TryHackMe this week🤖

💡 Thoughts on the ContAInment Room

This room was a hands-on investigation exercise set in a scenario where a company had suffered a security breach, resulting in important data being encrypted and used for blackmail. The goal was to investigate the compromised environment and discover the hidden flags🔎

I felt that this room built nicely on the concepts I learned in the previous AI Forensics room. One thing I especially enjoyed was solving the investigation by using a dedicated AI assistant available inside the victim environment🤖

As I worked through the challenge, I had to think carefully about what looked suspicious and follow clues step by step while actively using Linux commands. It also turned out to be a great review of Linux operations and practical investigation workflows🔥

📱 iOS (SwiftUI)

Worked through the SwiftUI tutorial and completed Sections 7 and 8: "Create an Algorithm for Badges"

🌐 Web Development

Posted my weekly dev log on Dev.to 📝
Created a new React Router v7 project for my future portfolio site.

🔐 Security (TryHackMe)

Completed the ContAInment room (part of the AI Security Learning Path) on TryHackMe.

💡 Key Takeaways

📱 SwiftUI Learning

Section 8: Calculate and Show Streaks

Learned how to calculate a daily streak by comparing saved dates with the current day.
Understood how reversing the array helps process moments from newest to oldest.
Learned how map and compactMap can transform Moment objects into simple day offsets like [0, 1, 2].
Understood how Calendar.dateComponents calculates date differences in calendar-based units.
Learned that multiple moments on the same day should count as a single streak day.
Realized that the streak variable represents the next expected day offset during the calculation.
Learned that comparing daysAgo == streak is a simple way to detect consecutive days.
Understood why using the end of the current day makes streak calculations more stable and predictable.
Learned that @ViewBuilder is used to build conditional or multiple-view UI structures, while Group is mainly used to organize existing views or share modifiers without affecting layout.
Understood that VStack creates all child views immediately, whereas LazyVStack generates views only when they become visible on screen.
Realized that LazyVStack is more suitable for scrollable, data-driven UIs with many or heavy views because it improves memory efficiency and performance.

🌐 Web Development Learning

React Router v7 Framework Mode is similar to Remix, so my Remix experience will still be useful.
root.tsx, routes.ts, and route files work together to render each page.

🔐 TryHackMe Learning

ContAInment

Identified useful indicators from attacker notes and used them to recover encrypted files.
Practiced DFIR-style investigation by following clues across logs, archives, and extracted data.
Used AI-assisted forensic tools to analyze encoded flag candidates and identify the correct flag.
Improved my understanding of how AI systems themselves can become targets in modern cyberattacks.

🚀 Next Week

Complete the badge algorithm in the SwiftUI tutorial.
Continue posting small articles on Dev.to and start creating Web UI designs in Figma.
Continue working on the AI Security Learning Path.

🌈 Goals for This Year

📱 iOS (SwiftUI)

Build a solid foundation in SwiftUI and create at least one iOS app.

🌐 Web Development

Continue posting learning logs on Dev.to and eventually turn them into a portfolio site using React Router v7.

🔐 Security (TryHackMe)

Continue learning cybersecurity on TryHackMe.

Weekly Dev Log 2026-W05

Umitomo — Fri, 15 May 2026 04:44:53 +0000

🗓️ This Week

Made a little more progress in the SwiftUI tutorial.
Started researching web technology stacks and creating a roadmap to gradually turn my current blog into a portfolio site using React Router v7. I'm moving forward little by little.
Completed the AI Forensics room from the AI Security Learning Path on TryHackMe this week.

💡 Thoughts on the AI Forensics Room

The AI Forensics room was much deeper and more challenging than I initially expected, and each task took a significant amount of time to complete. However, it turned out to be an incredibly valuable learning experience 🔥

Task 5, "Practical - The Digital Trail," was especially impressive. It was a story-driven hands-on investigation where I analyzed a compromised company environment after attackers stole critical proprietary source code 🔎

Instead of simply reading explanations, I had to actively investigate logs, suspicious files, reverse shells, persistence mechanisms, and data exfiltration activity step by step.

Because I was constantly thinking, investigating, and connecting the dots myself, the experience felt far more practical and realistic. It gave me a much deeper understanding of how AI-assisted DFIR investigations work in real-world scenarios.

One of the biggest lessons I learned from this room was that AI is a powerful tool, but human insight is still essential. AI can quickly detect suspicious activity, but investigators still need to analyze the context and validate the findings themselves.

📱 iOS (SwiftUI)

Worked through the SwiftUI tutorial and completed Sections 6 and 7: "Create an Algorithm for Badges"

🌐 Web Development

Posted my weekly dev log on Dev.to 📝
Researched how to transform my current blog site into the portfolio site I want to build in the future.
Created a roadmap with ChatGPT to gradually turn my blog site into a portfolio site.

🔐 Security (TryHackMe)

Completed the AI Forensics room (part of the AI Security Learning Path) on TryHackMe.

💡 Key Takeaways

📱 SwiftUI Review

Reviewed how SwiftData automatically creates relationships between @Model objects through model properties.
Understood how bidirectional relationships work between Moment and Badge models.
Learned that Group is useful when applying modifiers to conditionally displayed views.
Realized that SwiftUI modifiers can only be attached to actual views, not directly to an if statement.
Reviewed how @ViewBuilder allows a custom SwiftUI view to accept and display child views passed from outside.
Understood that .offset(y:) moves a view from its original position to fine-tune layouts.

🔐 TryHackMe Learning

AI Forensics Task 3 — AI & DFIR

Learned how AI and machine learning are transforming modern DFIR investigations.
Studied how CNN models can detect image tampering and manipulated content.
Learned how machine learning is used in dynamic malware analysis.
Understood that API call sequences represent program behavior patterns.
Studied how API sequences can be converted into 2D images for AI analysis.
Learned why CNN-based image recognition models can classify malware behavior.
Learned how NLP models help identify phishing emails and suspicious communications.
Understood how AI can reconstruct incident timelines from fragmented evidence.
Studied how AI accelerates forensic analysis and improves detection capabilities.
Understood that AI enhances human investigators rather than replacing them.
Learned the importance of combining AI-assisted analysis with human expertise in cybersecurity.

AI Forensics Task 4 — AI Legal & Ethical Implications

Learned that AI in forensics must be explainable and defensible in court.
Understood how “black box” AI models can weaken the credibility of digital evidence.
Learned that biased AI systems can lead to real-world injustice and wrongful accusations.
Studied the importance of maintaining chain of custody and audit trails when using AI in DFIR.
Understood why undocumented AI processing can make forensic evidence legally challengeable.
Learned that privacy and legal compliance are critical when handling sensitive evidence with AI tools.
Studied how Federated Learning and offline AI environments help preserve privacy.
Learned that AI should enhance human investigators, not replace human judgment and responsibility.

AI Forensics Task 5 — Practical: The Digital Trail

Learned how AI and machine learning can support DFIR investigations by identifying suspicious logs and files.
Studied how attackers use reverse shells to gain and maintain remote access to compromised systems.
Learned how hidden files, /tmp, and /dev/shm are commonly abused for stealth and persistence.
Understood how attackers disguise malicious tools as legitimate system utilities to evade detection.
Studied how SSH key abuse and authorized_keys modification can enable stealthy privilege escalation.
Learned how fake telemetry logs and masquerading techniques help attackers blend into normal environments.
Understood how compressed and Base64-encoded archives can be staged for data exfiltration.
Learned how DFIR investigations connect evidence from logs, bash history, suspicious files, and network activity.
Studied how AI can misclassify legitimate files as suspicious, highlighting the importance of human validation.
Learned that AI enhances investigations, but human reasoning and contextual analysis remain essential in DFIR.

🚀 Next Week

Complete the badge algorithm in the SwiftUI tutorial.
Continue posting small articles on Dev.to.
Continue working on the AI Security Learning Path.

🌈 Goals for This Year

📱 iOS (SwiftUI)

Build a solid foundation in SwiftUI and create at least one iOS app.

🌐 Web Development

Continue posting learning logs on Dev.to and eventually turn them into a portfolio site using React Router v7.

🔐 Security (TryHackMe)

Continue learning cybersecurity on TryHackMe.

Weekly Dev Log 2026-W04

Umitomo — Sat, 09 May 2026 05:36:45 +0000

🗓️ This Week

I had a long holiday during Golden Week in Japan and really enjoyed the break!
Because of that, I didn't have as much learning time compared to last week 😂
I made a little more progress in the SwiftUI tutorial
It was my first time using GitHub Copilot in Xcode, and I tried using the chat feature to generate unit tests. I'd also like to gradually explore more advanced features such as custom instructions.

I also want to thank everyone who commented on my previous Weekly Dev Log 2026-W03✨

Since English is not my native language, I was honestly a bit nervous about posting in English at first. But interacting with people on this platform has been a really valuable learning experience for me.

The kind comments and discussions gave me more confidence to continue sharing my learning journey here. Thank you so much😊

📱 iOS (SwiftUI)

Worked through the Swift tutorial and completed Section 5: "Create an Algorithm for Badges"
Used GitHub Copilot in Xcode to generate unit tests for badge sorting logic.

🌐 Web Development

Posted my weekly dev log on Dev.to 📝

🔐 Security (TryHackMe)

Worked on the AI Forensics room (part of the AI Security Learning Path) on TryHackMe

💡 Key Takeaways

Reviewed the basics of building SwiftUI views using NavigationStack, ScrollView, and HStack
Learned how to integrate AI-assisted code generation into the testing workflow.

TryHackMe Learning

AI Forensics

Learned how AI/ML enhances DFIR through large-scale data processing, anomaly detection, and scalable analysis
Explored practical AI use cases in DFIR tools, including phishing detection, malware classification, alert prioritisation, and event correlation
Learned the difference between deterministic systems and probabilistic AI models, and why non-determinism can become a challenge in digital forensics
Studied key AI evaluation metrics such as accuracy, precision, and recall, and learned why these metrics can be misleading when viewed in isolation
Understood the “Garbage In, Garbage Out (GIGO)” principle and how low-quality training data can lead to unreliable AI outputs
Learned that AI can accelerate DFIR workflows, but human oversight and validation are still essential in forensic investigations

🚀 Next Week

Continue working on the badge algorithm (Section 6) in the SwiftUI tutorial
Continue posting small articles on Dev.to
Continue working on the AI Security Learning Path

🌈 Goals for This Year

📱 iOS (SwiftUI)

Build a solid foundation in SwiftUI and create at least one iOS app

🌐 Web Development

Continue posting learning logs on Dev.to and eventually turn them into a portfolio site using React Router v7

🔐 Security (TryHackMe)

Keep learning cybersecurity on TryHackMe

Weekly Dev Log 2026-W03

Umitomo — Tue, 28 Apr 2026 06:21:07 +0000

🗓️ This Week

Finally finished the Cyber Security 101 learning path and discovered the AI Security Learning Path on TryHackMe
Completed 2 rooms from the AI Security Learning Path this week
Decided to continue working on the SwiftUI tutorial (also explored React Native with Expo out of curiosity)

📱 iOS (SwiftUI)

Ran unit tests for badge unlocking logic and stepped through them using breakpoints
Researched the differences between SwiftUI and React Native (with Expo) to determine the best platform for my learning

🌐 Web Development

Posted my weekly learning and development log on Dev.to📝

🔐 Security (TryHackMe)

Completed 2 rooms from the AI Security Learning Path on TryHackMe (AI Models & Data, Prompt Engineering)

💡 Key Takeaways

Learned how to use the po command and the map function in the console during debugging
Chose SwiftUI to focus on native iOS development (compared to React Native with Expo)

TryHackMe Learning

AI Models & Data

Learned that most AI models rely heavily on Common Crawl, a large public dataset collected from the internet
Realized that unclear data provenance and hidden sensitive data can lead to security risks
Learned that training decisions can impact security, including potential data leakage
Understood that optimization techniques introduce trade-offs between efficiency and security
Learned that fine-tuning inherits risks from base models such as bias and unsafe behavior
Realized that models are black boxes and difficult to fully audit
Learned that model cards are important but often incomplete

Prompt Engineering

Learned that LLMs process text as tokens and generate probabilistic outputs
Learned how parameters like temperature and top-p affect responses
Learned that effective prompts require clear instructions, context, format, and constraints
Understood the difference between system prompts and user prompts
Practiced prompt techniques such as zero-shot, few-shot, and Chain-of-Thought

🚀 Next Week

Continue working on the badge algorithm (Section 5) in the SwiftUI tutorial
Continue posting small articles on Dev.to
Continue working on the AI security Learning Path

Weekly Dev Log 2026-W02

Umitomo — Wed, 22 Apr 2026 07:24:49 +0000

🗓️ This Week

📱 iOS (SwiftUI)

Worked on the SwiftUI tutorial and completed Section 4 (Create an algorithm for badges)
Built a test file to verify the badge algorithm
Created unit tests for badge unlocking logic using an in-memory SwiftData container
Ran unit tests and stepped through them using breakpoint

🌐 Web Development

Posted my weekly learning and development log on Dev.to

🔐 Security (TryHackMe)

Completed OWASP Top 10 2025: Insecure Data Handling on TryHackMe
Worked on the AI/ML Security Threats room and completed Tasks 1–4

💡 Key Takeaways

Learned how to use MARK: comments for code organization
Understood the difference between insert and save, and how to isolate business logic from the UI
Reviewed how to inspect variable values during debugging
Learned how SSTI can lead to server-side code execution
Understood the difference between Base64 encoding and actual encryption
Reviewed the basics of AI/ML
Learned how LLMs work

🚀 Next Week

Test the badge algorithm and complete the SwiftUI tutorial section
Continue posting small articles on Dev.to
Continue working on the AI security learning path

Weekly Dev Log 2026-W01

Umitomo — Fri, 17 Apr 2026 07:22:41 +0000

🗓️ This Week

📱 iOS (SwiftUI)

Worked on the SwiftUI tutorial and completed Section 4 Steps 9–12 (Create an algorithm for badges)

🌐 Web Development

Started posting articles on Dev.to
Managing my articles using GitHub and GitHub Actions

🔐 Security (TryHackMe)

Completed OWASP Top 10 2025: IAAA Failures and Application Design Flaws on TryHackMe

💡 Key Takeaways

Learned basic state management through implementing a badge system in SwiftUI
Building a habit of posting regularly is important for consistency
Application design flaws can lead to serious security vulnerabilities
Relearned how to check port status using nc and Nmap in Bash
Learned how to send POST requests using curl
Learned how to decrypt data using OpenSSL
Understood the difference between Base64 encoding and AES-128-ECB encryption
Learned how to use Gobuster

🚀 Next Week

Test the badge algorithm implementation
Continue posting small articles on Dev.to
Complete the remaining OWASP challenge rooms

Hello Dev.to!👋 I'm starting my journey as a developer🌱

Umitomo — Wed, 15 Apr 2026 02:52:20 +0000

👋 Hello Dev.to!

Hi, I'm Umitomo 🐠 from Japan 🇯🇵

I work as an in-house systems engineer, mainly focusing on IT infrastructure and security.

💼 What I do

In my daily work, I handle IT infrastructure and security operations.

Outside of work, I enjoy building things as a hobby and have been learning:

SwiftUI (iOS development)
Web development (Remix, Cloudflare)
Cybersecurity (TryHackMe)

🚀 What I'm building

🌐 Web Development

I built a personal blog using Remix + Cloudflare + microCMS.

Since I plan to publish articles on Dev.to, I'm thinking about turning it into a portfolio site using React Router v7.

📱 iOS Development

I'm currently learning SwiftUI through tutorials.

I'd love to build apps that I can enjoy with my kids.

🎯 Why I'm here

I chose Dev.to because:

I want to challenge myself to write in English
I like the culture where it's okay to share not only tutorials but also personal learning journeys

I feel it's a great place to grow as a developer while sharing my progress.

✍️ What I’ll write about

My journey from infrastructure to development
Development logs and technical notes
Security learning and experiments

🌱 My goal

I'm starting small, but I want to stay consistent and keep learning step by step.

🙌 Nice to meet you!

Feel free to connect with me!

DEV Community: Umitomo

A Curious Journey Into Reverse Engineering an AI-Generated Python .exe

Introduction

TL;DR

What I Reverse Engineered

Reverse Engineering Environment Setup

Creating a Python Virtual Environment

Installing Basic Analysis Tools

Building pycdc

Extracting the PyInstaller Executable

How I Reverse Engineered It

Step 1 — Running strings

Step 2 — Inspecting the PyInstaller Archive

Step 3 — Analyzing .pyc Files

Step 4 — Investigating the Frontend

Reconstructing the Architecture

What I Learned

Reverse Engineering Can Reveal More Than I Expected

“Working Software” and “Understandable Software” Are Different Things

Final Thoughts

Weekly Dev Log 2026-W06

🗓️ This Week

💡 Thoughts on the ContAInment Room

📱 iOS (SwiftUI)

🌐 Web Development

🔐 Security (TryHackMe)

💡 Key Takeaways

📱 SwiftUI Learning

Section 8: Calculate and Show Streaks

🌐 Web Development Learning

🔐 TryHackMe Learning

ContAInment

🚀 Next Week

🌈 Goals for This Year

📱 iOS (SwiftUI)

🌐 Web Development

🔐 Security (TryHackMe)

Weekly Dev Log 2026-W05

🗓️ This Week

💡 Thoughts on the AI Forensics Room

📱 iOS (SwiftUI)

🌐 Web Development

🔐 Security (TryHackMe)

💡 Key Takeaways

📱 SwiftUI Review

🔐 TryHackMe Learning

AI Forensics Task 3 — AI & DFIR

AI Forensics Task 4 — AI Legal & Ethical Implications

AI Forensics Task 5 — Practical: The Digital Trail

🚀 Next Week

🌈 Goals for This Year

📱 iOS (SwiftUI)

🌐 Web Development

🔐 Security (TryHackMe)

Weekly Dev Log 2026-W04

🗓️ This Week

📱 iOS (SwiftUI)

🌐 Web Development

🔐 Security (TryHackMe)

💡 Key Takeaways

TryHackMe Learning

AI Forensics

🚀 Next Week

🌈 Goals for This Year

📱 iOS (SwiftUI)

🌐 Web Development

🔐 Security (TryHackMe)

Weekly Dev Log 2026-W03

🗓️ This Week

📱 iOS (SwiftUI)

🌐 Web Development

🔐 Security (TryHackMe)

💡 Key Takeaways

TryHackMe Learning

AI Models & Data

Prompt Engineering

🚀 Next Week

Weekly Dev Log 2026-W02

🗓️ This Week

📱 iOS (SwiftUI)

Building `pycdc`

Step 1 — Running `strings`

Step 3 — Analyzing `.pyc` Files