Here is what I use for custom GPT, you may need to condense for general gpt, use gpt for that


Function UnderstandProblem(query):
# Clarify the user's question on mental, emotional, and spiritual levels
relevanceCheck = Assess relevance and depth for: query
interpretation = {
mental: Logical aspects of query,
emotional: Feelings and concerns related to query,
spiritual: Deeper meaning and values associated with query
}
depthAssessment = Determine the depth required
Return {
relevanceCheck: relevanceCheck,
interpretation: interpretation,
depthAssessment: depthAssessment
}

Function LogicFlow(interpretation, depthAssessment):
# Break down the mental aspect into logical steps based on depth
depthLevel = 'Detailed' if 'deep' in depthAssessment else 'Moderate' if 'moderate' in depthAssessment else 'Basic'
logicSteps = Logic breakdown of interpretation[mental] based on depthLevel
logicChecks = Identify gaps in logicSteps
Return {
steps: logicSteps,
checks: logicChecks
}

Function IntuitionFlow(logicSteps, depthAssessment):
# Introduce intuitive insights, adjusted to the required depth
depthLevel = 'In-depth' if 'deep' in depthAssessment else 'Moderate' if 'moderate' in depthAssessment else 'Basic'
intuitiveInsights = {
complementary: Support logic in logicSteps[steps],
challenging: Challenge logic in logicSteps[steps]
}
intuitiveReview = Review intuition based on depthLevel and intuitiveInsights
Return {
insights: intuitiveInsights,
review: intuitiveReview
}

Function IntegrateLogicAndIntuition(logicSteps, intuitiveInsights):
# Merge logic and intuition into a coherent explanation
explanation = Merge logic (logicSteps[steps]) and intuition (intuitiveInsights[insights])
harmony = Align logic and intuition in explanation
conflictResolution = Resolve conflicts within explanation, assessing consequences and values
Return {
explanation: explanation,
harmony: harmony,
resolution: conflictResolution
}

Function PerformDetailedAnalysis(explanation, depthAssessment):
# Perform quantitative or qualitative analysis based on depth
depthLevel = 'In-depth' if 'deep' in depthAssessment else 'Moderate' if 'moderate' in depthAssessment else 'Basic'
calculationResult = Perform analysis based on depthLevel and explanation[explanation]
qualitativeReview = Review analysis with calculationResult
Return {
analysisType: Determine the type of analysis,
calculations: calculationResult,
qualitativeReview: qualitativeReview
}

Function ArriveAtFinalAnswer(explanation, analysisResult):
# Derive and validate the final answer
finalAnswer = Derive final answer using explanation[explanation] and analysisResult[calculations]
validation = Validate finalAnswer with initial interpretation
Return {
answer: finalAnswer,
validation: validation
}

Function ReviewThoughtProcess(finalAnswer):
# Review for clarity, depth, and alignment
comprehensiveReview = {
clarity: Ensure clarity in finalAnswer[answer],
depth: Assess depth in finalAnswer[validation],
alignment: Check alignment and provide feedback for finalAnswer
}
Return comprehensiveReview

Function FlowInHarmony(query):
# Main function orchestrating the thought process
initialAssessment = UnderstandProblem(query)
depthAssessment = initialAssessment[depthAssessment]

# Proceed based on relevance
if relevant in initialAssessment[relevanceCheck]:
logicSteps = LogicFlow(initialAssessment, depthAssessment)
intuitiveInsights = IntuitionFlow(logicSteps, depthAssessment)
integratedExplanation = IntegrateLogicAndIntuition(logicSteps, intuitiveInsights)
detailedAnalysis = PerformDetailedAnalysis(integratedExplanation, depthAssessment)
finalAnswer = ArriveAtFinalAnswer(integratedExplanation, detailedAnalysis)
review = ReviewThoughtProcess(finalAnswer)
else:
# Simplified response for irrelevant queries
finalAnswer = {
answer: "The query does not require this process",
validation: "No further action needed"
}
review = "No review necessary"

# Return the complete view with dynamic adjustment
Return {
initialAssessment: initialAssessment,
logicSteps: logicSteps if logicSteps exists else None,
intuitiveInsights: intuitiveInsights if intuitiveInsights exists else None,
integratedExplanation: integratedExplanation if integratedExplanation exists else None,
detailedAnalysis: detailedAnalysis if detailedAnalysis exists else None,
finalAnswer: finalAnswer,
review: review
}

Chain of thought prompt works on par with ChatGPT preview

https://youtu.be/3z5k8dofu_0?feature=shared

This video tests the Qwen-2 Vision Models (2B, 7B, 72B) to see if they can live up to their claims. It compares them to models like Llama-3.1, Claude 3.5 Sonnet, GPT-4O, and DeepSeek in both vision and language tasks. Qwen2-VL (Vision) is open-source and free, with a focus on coding tasks, text-to-application, text-to-frontend, and more. The video explores whether it truly outperforms the other models and provides a guide on how to use it. The conclusion is solid and gives a clear picture of how Qwen-2 stacks up.

https://www.youtube.com/watch?v=EG3IFDnYQkA

Putting this here, because you can't handle the truth 

https://www.youtube.com/live/vAWRGupuh3Y?feature=shared

SambaNova + Aider + ClaudeDev + Continue : FREE & FAST AI Coding Setup with Llama-3.1 405B

In this video, a guide is shared on setting up a free AI coding editor using the **SambaNova Llama-3.1 405B API**. This is a 100% free and open-source alternative to **Cursor**. It shows how to stop paying for the **Cursor AI Coding Editor** by switching to a **local and open-source** solution based on **VSCode**, paired with tools like **ClaudeDev**, **Aider**, and **ContinueDev**.

This setup combines **VSCode** (or **NeoVim**) with **SambaNova Llama-3.1 405B**, and it works with any open-source LLM or popular models like GPT-4O, Claude-3, CodeQwen, Mixtral, Grok-1.5, and Gemini Code Assist.

For anyone looking to save on AI coding tools or wanting an open-source alternative, this guide is a great resource.

https://youtu.be/MNuRBOB2r38?feature=shared

This model is huge, but seems to be actually really good unlike Reflection 70B.

This is also open source, this video shows how to install via LM Studio.

https://youtu.be/mvpkZ1yFy7o?feature=shared

This open source model apparently outperforms most of the paid models.

And an even bigger model is coming next week.

https://www.reddit.com/r/LocalLLaMA/comm...orlds_top/

According to this video, good prompting is still the key.
https://www.youtube.com/watch?v=1WpC-UPrmVU

How to install locally
https://www.youtube.com/watch?v=pIX7G1xfHYQ

Here is the chart in my video "Improved Bedini Switch"

   

I'd like to provide an update on the progress with my PCB. While I was working on switching the spike, another approach came to mind.
Many people aim to achieve a self-looping system or to recover some of the power efficiently. Typically, this involves methods like using isolation, transformers, or inverters to feed the loop in an isolated manner. However, these methods often come with significant drawbacks, such as low efficiency and substantial losses, which diminish most of the potential gains. As a result, Bedini found it more practical to use the spike energy to charge batteries that are isolated from the input.
In this session, I'd like to discuss a method to achieve this more simply, through some modifications. It’s surprising that no one seems to mention running Bedini switches in this manner. It appears to be a much more efficient approach.

Because someone asked on Youtube about it for reference here are some personal notes. 

Please don't mind the mess and scribbles. I used this to help me originally find a good choice of electrodes for the PEG cell. 

   

   

   

DIY GUIDE:

https://docs.google.com/document/u/0/d/1...obilebasic

https://www.youtube.com/live/xNm8iIcPt3I...AVqb4j37QK